先日作成した、クラウドサービスとのデータコピーを行えるrcloneのGUI版「EasyRclone」。自分の使い方では動作に問題はなさそうなので本格的に運用していきたいと思います。それに伴い、デザインを変更してみました。動作自体は全く変わっていないので、前のデザインのほうがよければ前のバージョンでも。
履歴画面は次のような感じです。
使用方法などは前と全く変わらないので、そちらを参照してください。
LXDコンテナにインストール
#!/bin/bash
set -e
INSTALL_DIR="/opt/easyrclone"
unset PORT
APP_PORT="${EASYRCLONE_PORT:-3348}"
echo "========================================="
echo " EasyRclone Installer v7"
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 32 32'><rect rx='8' width='32' height='32' fill='%236366f1'/><text x='16' y='22' font-size='18' text-anchor='middle' fill='white' font-family='system-ui' font-weight='bold'>R</text></svg>">
  <link rel="stylesheet" href="/css/style.css">
</head>
<body>
  <header class="app-header">
    <div class="header-left">
      <div class="logo-icon">
        <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"/><path d="M12 12v9"/><path d="m8 17 4 4 4-4"/></svg>
      </div>
      <h1>EasyRclone</h1>
    </div>
    <div class="header-right">
      <button class="btn-icon-header accent" onclick="openAddModal('drive')">
        <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 5v14"/><path d="M5 12h14"/></svg>
        <span class="btn-label">Googleドライブ</span>
      </button>
      <button class="btn-icon-header accent" onclick="openAddModal('onedrive')">
        <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 5v14"/><path d="M5 12h14"/></svg>
        <span class="btn-label">OneDrive</span>
      </button>
      <button class="btn-icon-header" onclick="exportSettings()">
        <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg>
        <span class="btn-label">エクスポート</span>
      </button>
      <button class="btn-icon-header" onclick="importSettings()">
        <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="17 8 12 3 7 8"/><line x1="12" y1="3" x2="12" y2="15"/></svg>
        <span class="btn-label">インポート</span>
      </button>
      <button class="btn-icon-header nav-btn" data-page="jobs" onclick="showPage('jobs')">
        <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8Z"/><path d="M14 2v6h6"/><path d="M16 13H8"/><path d="M16 17H8"/><path d="M10 9H8"/></svg>
        <span class="btn-label">履歴</span>
      </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>
            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/></svg>
            スケジュール設定
          </h3>
          <div class="schedule-time-row">
            <select id="schedule-time-select">
              <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">
              <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>
          <div class="btn-row">
            <button class="btn btn-pastel btn-sm" onclick="saveSchedule()">スケジュール保存</button>
            <button class="btn btn-outline btn-sm" onclick="showCronInfo()">cron設定確認</button>
          </div>
          <div id="cron-info-area" style="display:none">
            <div id="cron-info-content" class="cron-info-box"></div>
          </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')">
          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m12 19-7-7 7-7"/><path d="M19 12H5"/></svg>
          戻る
        </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()">
          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M18 6 6 18"/><path d="m6 6 12 12"/></svg>
        </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>
          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M15 3h4a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-4"/><polyline points="10 17 15 12 10 7"/><line x1="15" y1="12" x2="3" y2="12"/></svg>
          アカウント認証
        </h3>
        <button class="modal-close" onclick="closeModal()">
          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M18 6 6 18"/><path d="m6 6 12 12"/></svg>
        </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">
              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="16" x="2" y="4" rx="2"/><path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"/></svg>
              1. SSHトンネルを接続:
            </div>
            <div class="ssh-tunnel-cmd">
              <code id="ssh-cmd"></code>
              <button class="btn btn-outline btn-sm" onclick="copySshCmd()">
                <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect width="14" height="14" x="8" y="8" rx="2" ry="2"/><path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"/></svg>
              </button>
            </div>
          </div>
          <div class="auth-url-box" style="margin-top:8px">
            <label>2. ブラウザでログイン:</label>
            <div class="auth-url-input-row">
              <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()">
                <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect width="14" height="14" x="8" y="8" rx="2" ry="2"/><path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"/></svg>
              </button>
            </div>
          </div>
        </div>
        <div id="auth-done-area" style="display:none;text-align:center;padding:24px 0">
          <div style="width:48px;height:48px;border-radius:12px;background:var(--success-bg);display:flex;align-items:center;justify-content:center;margin:0 auto 12px">
            <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="var(--success)" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 6 9 17l-5-5"/></svg>
          </div>
          <p style="color:var(--success);font-weight:600;font-size: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:560px" onclick="event.stopPropagation()">
      <div class="modal-header">
        <h3>
          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 5v14"/><path d="M5 12h14"/></svg>
          同期ペアを追加
        </h3>
        <button class="modal-close" onclick="closeModal()">
          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M18 6 6 18"/><path d="m6 6 12 12"/></svg>
        </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-pair-prefix" id="pair-prefix">gdrive:</span>
            <input type="text" id="pair-dest" class="sync-pair-dest-input" placeholder="/backup">
          </div>
        </div>
        <label class="checkbox" style="margin:10px 0">
          <input type="checkbox" id="pair-delete">
          <span>コピー元にないファイルをコピー先で削除</span>
        </label>
      </div>
      <div class="modal-footer">
        <button class="btn btn-outline" onclick="closeModal()">キャンセル</button>
        <button class="btn btn-pastel" onclick="saveSyncPair()">追加</button>
      </div>
    </div>
  </div>

  <div id="toast" class="toast"></div>
  <script src="/js/app.js?v=7"></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') || '[]'));

const ICONS = {
  plus: '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 5v14"/><path d="M5 12h14"/></svg>',
  key: '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m21 2-2 2m-7.61 7.61a5.5 5.5 0 1 1-7.778 7.778 5.5 5.5 0 0 1 7.777-7.777zm0 0L15.5 7.5m0 0 3 3L22 7l-3-3m-3.5 3.5L19 4"/></svg>',
  link: '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71"/><path d="M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71"/></svg>',
  trash: '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 6h18"/><path d="M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6"/><path d="M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2"/></svg>',
  settings: '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12.22 2h-.44a2 2 0 0 0-2 2v.18a2 2 0 0 1-1 1.73l-.43.25a2 2 0 0 1-2 0l-.15-.08a2 2 0 0 0-2.73.73l-.22.38a2 2 0 0 0 .73 2.73l.15.1a2 2 0 0 1 1 1.72v.51a2 2 0 0 1-1 1.74l-.15.09a2 2 0 0 0-.73 2.73l.22.38a2 2 0 0 0 2.73.73l.15-.08a2 2 0 0 1 2 0l.43.25a2 2 0 0 1 1 1.73V20a2 2 0 0 0 2 2h.44a2 2 0 0 0 2-2v-.18a2 2 0 0 1 1-1.73l.43-.25a2 2 0 0 1 2 0l.15.08a2 2 0 0 0 2.73-.73l.22-.39a2 2 0 0 0-.73-2.73l-.15-.08a2 2 0 0 1-1-1.74v-.5a2 2 0 0 1 1-1.74l.15-.09a2 2 0 0 0 .73-2.73l-.22-.38a2 2 0 0 0-2.73-.73l-.15.08a2 2 0 0 1-2 0l-.43-.25a2 2 0 0 1-1-1.73V4a2 2 0 0 0-2-2z"/><circle cx="12" cy="12" r="3"/></svg>',
  sync: '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 12a9 9 0 0 0-9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"/><path d="M3 3v5h5"/><path d="M3 12a9 9 0 0 0 9 9 9.75 9.75 0 0 0 6.74-2.74L21 16"/><path d="M16 16h5v5"/></svg>',
  edit: '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17 3a2.85 2.83 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5Z"/></svg>',
  cloud: '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z"/></svg>',
  check: '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 6 9 17l-5-5"/></svg>',
  x: '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M18 6 6 18"/><path d="m6 6 12 12"/></svg>',
  clock: '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/></svg>',
  copy: '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect width="14" height="14" x="8" y="8" rx="2" ry="2"/><path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"/></svg>',
  arrowRight: '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12h14"/><path d="m12 5 7 7-7 7"/></svg>',
  arrowLeft: '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m12 19-7-7 7-7"/><path d="M19 12H5"/></svg>',
  terminal: '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="4 17 10 11 4 5"/><line x1="12" y1="19" x2="20" y2="19"/></svg>',
  history: '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"/><path d="M3 3v5h5"/><path d="M12 7v5l4 2"/></svg>',
  folderOpen: '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="m6 14 1.5-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.54 6a2 2 0 0 1-1.95 1.5H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H18a2 2 0 0 1 2 2v2"/></svg>',
  fileText: '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M10 9H8"/><path d="M16 13H8"/><path d="M16 17H8"/></svg>',
  stop: '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="20" x="2" y="2" rx="4"/></svg>',
};

function icon(name, size) {
  const svg = ICONS[name] || '';
  if (size && svg) return svg.replace(/width="\d+"/, `width="${size}"`).replace(/height="\d+"/, `height="${size}"`);
  return svg;
}

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');
  const iconHtml = type === 'success' ? icon('check') : type === 'error' ? icon('x') : icon('clock');
  t.innerHTML = iconHtml + 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');
}

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">${icon('cloud')}</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);
    const typeLabel = r.type === 'drive' ? 'Google ドライブ' : 'OneDrive';
    const typeIcon = r.type === 'drive'
      ? '<svg width="20" height="20" viewBox="0 0 24 24" fill="white"><path d="M7.71 3.5 1.15 15l3.43 6h13.14l3.43-6L15.29 3.5H7.71z"/></svg>'
      : '<svg width="20" height="20" viewBox="0 0 24 24" fill="white"><path d="M10.5 18.5h-6a3.5 3.5 0 0 1-.72-6.93A5 5 0 0 1 14.56 8H18a3.5 3.5 0 0 1 .5 6.94"/><path d="M18 8V6.5a3.5 3.5 0 0 0-7 0V8"/></svg>';

    html += `
    <div class="card remote-card">
      <div class="remote-card-header">
        <div class="remote-card-left">
          <div class="remote-icon ${r.type}">${typeIcon}</div>
          <div>
            <div class="remote-card-name">${esc(r.name)}</div>
            <div class="remote-card-type">${typeLabel}</div>
          </div>
        </div>
        <div class="remote-card-actions">
          <button class="btn btn-outline btn-sm" onclick="setupSsh()">${icon('terminal')} 一時SSH</button>
          <button class="btn btn-pastel btn-sm" onclick="startAuthFlow('${esc(r.name)}','${r.type}')">${icon('key')} 認証</button>
          <button class="btn btn-outline btn-sm" onclick="testRemote('${esc(r.name)}')">${icon('link')} テスト</button>
          <button class="btn btn-outline btn-sm" onclick="teardownSsh()">${icon('trash')} SSH削除</button>
          <button class="btn btn-pastel-green btn-sm" onclick="openAddPair('${esc(r.name)}','${r.type}')">${icon('plus')} 同期ペア追加</button>
          <button class="btn btn-danger btn-sm" onclick="deleteRemote('${esc(r.name)}')">${icon('trash')} 削除</button>
        </div>
      </div>`;

    if (pairs.length) {
      html += '<div class="sync-pairs-area">';
      html += '<div class="sync-pairs-area-title">同期ペア</div>';
      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">${icon('arrowRight')}</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-pastel btn-sm" onclick="syncPairNow(${pi})">${icon('sync')} 同期</button>
            <button class="btn btn-outline btn-sm" onclick="editPair(${pi})">${icon('edit')} 編集</button>
            <button class="btn btn-danger btn-sm" onclick="deletePair(${pi})">${icon('trash')}</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');
  try {
    const d = await api(`/api/remotes/${n}/test`, { method: 'POST' });
    showToast(d.ok ? `${n} 接続成功` : `失敗: ${(d.error || '').substring(0, 80)}`, d.ok ? 'success' : 'error');
  } catch (e) {
    showToast('テスト失敗: ' + e.message, 'error');
  }
}

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

// === SSH ===
async function setupSsh() {
  showToast('SSH設定中...', 'info');
  try {
    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');
  } catch (e) { showToast('失敗: ' + e.message, 'error'); }
}

async function teardownSsh() {
  if (!confirm('一時SSH設定を削除しますか？')) return;
  try {
    const d = await api('/api/ssh/teardown', { method: 'POST' });
    showToast(d.ok ? '削除しました' : '失敗', d.ok ? 'success' : 'error');
  } catch (e) { showToast('失敗: ' + e.message, '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 class="modal-footer" style="padding:0;margin-top:16px">
      <button class="btn btn-outline" onclick="closeModal()">キャンセル</button>
      <button class="btn btn-pastel" onclick="addRemoteOnly()">追加する</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; }
  try {
    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();
  } catch (e) { showToast('失敗: ' + e.message, 'error'); }
}

// === 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 = `${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);
  try {
    await saveSettings();
    showToast('削除しました', 'success');
    loadAll();
  } catch (e) { showToast('失敗: ' + e.message, 'error'); }
}

async function syncPairNow(idx) {
  const p = syncPairs[idx];
  if (!p) return;
  showToast('同期開始...', 'info');
  try {
    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');
  } catch (e) { showToast('失敗: ' + e.message, 'error'); }
}

let editingPairIdx = -1;

function editPair(idx) {
  editingPairIdx = idx;
  const p = syncPairs[idx];
  const remoteName = p.remoteName || allRemotes[0]?.name || 'gdrive';
  addingPairFor = remoteName;
  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 0;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">${icon('clock')} ${t}</span>
      <button class="btn btn-danger btn-sm" onclick="syncSchedule.splice(${i},1);renderSyncSchedule()">${icon('trash')}</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 !== 'none') { 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">${icon('fileText')}</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 class="sync-arrow">${icon('arrowRight')}</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: #6366f1;
  --primary-hover: #4f46e5;
  --primary-light: #eef2ff;
  --primary-50: rgba(99,102,241,0.08);
  --bg: #f8fafc;
  --card: #ffffff;
  --text: #0f172a;
  --text2: #334155;
  --text3: #94a3b8;
  --border: #e2e8f0;
  --border2: #cbd5e1;
  --success: #10b981;
  --success-bg: #ecfdf5;
  --danger: #ef4444;
  --danger-bg: #fef2f2;
  --warning: #f59e0b;
  --warning-bg: #fffbeb;
  --drive: #34a853;
  --onedrive: #0078d4;
  --radius: 12px;
  --radius-sm: 8px;
  --radius-xs: 6px;
  --shadow: 0 1px 2px rgba(0,0,0,0.04);
  --shadow-sm: 0 1px 3px rgba(0,0,0,0.06), 0 1px 2px rgba(0,0,0,0.04);
  --shadow-md: 0 4px 6px -1px rgba(0,0,0,0.07), 0 2px 4px -2px rgba(0,0,0,0.05);
  --transition: 0.15s ease;
}

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

/* Header */
.app-header {
  background: var(--card);
  border-bottom: 1px solid var(--border);
  color: var(--text); padding: 0 28px; height: 60px;
  display: flex; align-items: center; justify-content: space-between;
  position: sticky; top: 0; z-index: 100;
}
.header-left { display: flex; align-items: center; gap: 12px; }
.header-left .logo-icon {
  width: 32px; height: 32px; border-radius: 8px;
  background: var(--primary); display: flex; align-items: center; justify-content: center;
}
.header-left h1 { font-size: 1.05rem; font-weight: 700; color: var(--text); letter-spacing: -0.01em; }
.header-right { display: flex; gap: 6px; align-items: center; }

/* Icon Buttons (header) */
.btn-icon-header {
  display: inline-flex; align-items: center; gap: 6px;
  background: transparent; border: 1px solid var(--border);
  color: var(--text2); padding: 7px 14px; border-radius: var(--radius-sm);
  cursor: pointer; font-size: 0.82rem; font-weight: 500;
  transition: all var(--transition); white-space: nowrap;
}
.btn-icon-header:hover { background: var(--bg); border-color: var(--border2); color: var(--text); }
.btn-icon-header svg { width: 15px; height: 15px; flex-shrink: 0; }
.btn-icon-header.active { background: var(--primary-light); border-color: var(--primary); color: var(--primary); }
.btn-icon-header.accent {
  background: var(--primary); border-color: var(--primary); color: white;
}
.btn-icon-header.accent:hover { background: var(--primary-hover); border-color: var(--primary-hover); }

/* Layout */
.content { max-width: 1080px; margin: 0 auto; padding: 28px 20px; }
.page { display: none; }
.page.active { display: block; }

.page-header { margin-bottom: 24px; display: flex; align-items: center; justify-content: space-between; }
.page-header h2 { font-size: 1.25rem; font-weight: 700; letter-spacing: -0.01em; }
.page-header .desc { color: var(--text3); font-size: 0.88rem; }

/* Cards */
.card {
  background: var(--card); border: 1px solid var(--border); border-radius: var(--radius);
  padding: 20px 24px; margin-bottom: 16px;
}
.card h3 {
  font-size: 0.95rem; font-weight: 600; margin-bottom: 16px;
  display: flex; align-items: center; gap: 8px; color: var(--text);
}
.card h3 svg { width: 18px; height: 18px; color: var(--text3); }

/* Remote Cards */
.remote-cards { display: grid; gap: 16px; }
.remote-card { padding: 0; overflow: hidden; }
.remote-card-header {
  display: flex; align-items: center; justify-content: space-between;
  padding: 18px 24px; flex-wrap: wrap; gap: 12px;
}
.remote-card-left { display: flex; align-items: center; gap: 14px; }
.remote-icon {
  width: 40px; height: 40px; border-radius: 10px;
  display: flex; align-items: center; justify-content: center;
  color: white;
}
.remote-icon svg { width: 20px; height: 20px; }
.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.78rem; color: var(--text3); margin-top: 1px; }
.remote-card-actions { display: flex; gap: 6px; flex-wrap: wrap; }

/* Sync Pairs Area */
.sync-pairs-area { padding: 0 24px 18px; }
.sync-pairs-area-title {
  font-size: 0.78rem; font-weight: 600; color: var(--text3);
  text-transform: uppercase; letter-spacing: 0.04em;
  margin-bottom: 10px; padding-top: 14px; border-top: 1px solid var(--border);
}
.sync-pair-row {
  display: flex; align-items: center; gap: 10px; padding: 10px 14px;
  background: var(--bg); border: 1px solid var(--border);
  border-radius: var(--radius-sm); margin-bottom: 8px;
  font-size: 0.85rem; justify-content: space-between;
}
.sync-pair-left { display: flex; align-items: center; gap: 8px; flex: 1; min-width: 0; }
.sync-pair-path { font-family: 'SF Mono', 'Fira Code', monospace; font-size: 0.8rem; color: var(--text2); word-break: break-all; }
.sync-pair-right { display: flex; align-items: center; gap: 6px; flex-shrink: 0; }
.sync-arrow { color: var(--primary); font-weight: 700; flex-shrink: 0; font-size: 0.85rem; }
.sync-error-link {
  font-size: 0.75rem; color: var(--danger); cursor: pointer;
  text-decoration: none; white-space: nowrap; font-weight: 500;
}
.sync-error-link:hover { text-decoration: underline; }
.tag { display: inline-flex; align-items: center; gap: 4px; padding: 2px 8px; border-radius: 4px; font-size: 0.72rem; font-weight: 600; }
.tag-red { background: var(--danger-bg); color: #b91c1c; }
.tag svg { width: 12px; height: 12px; }

/* Buttons */
.btn {
  padding: 8px 14px; border-radius: var(--radius-xs); font-size: 0.82rem;
  font-weight: 500; cursor: pointer; border: none; transition: all var(--transition);
  display: inline-flex; align-items: center; gap: 5px; white-space: nowrap;
}
.btn svg { width: 14px; height: 14px; flex-shrink: 0; }
.btn-primary { background: var(--primary); color: white; }
.btn-primary:hover { background: var(--primary-hover); }
.btn-danger { background: transparent; border: 1px solid var(--danger); color: var(--danger); }
.btn-danger:hover { background: var(--danger); color: white; }
.btn-success { background: var(--success); color: white; }
.btn-success:hover { background: #059669; }
.btn-pastel { background: #e0e7ff; color: #4338ca; border: none; }
.btn-pastel:hover { background: #c7d2fe; }
.btn-pastel-green { background: #d1fae5; color: #047857; border: none; }
.btn-pastel-green:hover { background: #a7f3d0; }
.btn-outline { background: transparent; border: 1px solid var(--border); color: var(--text2); }
.btn-outline:hover { background: var(--bg); border-color: var(--border2); }
.btn-sm { padding: 5px 10px; font-size: 0.78rem; }
.btn-sm svg { width: 13px; height: 13px; }
.btn-lg { padding: 12px 28px; font-size: 0.95rem; }
.btn:disabled { opacity: 0.5; cursor: not-allowed; }

/* Empty State */
.empty-state { text-align: center; padding: 48px 24px; color: var(--text3); }
.empty-icon {
  width: 56px; height: 56px; border-radius: 14px; margin: 0 auto 16px;
  background: var(--bg); border: 1px solid var(--border);
  display: flex; align-items: center; justify-content: center;
}
.empty-icon svg { width: 24px; height: 24px; color: var(--text3); }
.empty-state h3 { font-size: 1rem; color: var(--text2); margin-bottom: 4px; font-weight: 600; }
.empty-state p { font-size: 0.85rem; }

/* Schedule Section */
.schedule-section { margin-top: 24px; }
.schedule-time-row { display: flex; gap: 8px; align-items: center; margin-bottom: 12px; }
.schedule-time-row select {
  padding: 8px 12px; border: 1px solid var(--border); border-radius: var(--radius-xs);
  font-size: 0.85rem; background: var(--card); color: var(--text);
}
.schedule-time-row select:focus { outline: none; border-color: var(--primary); }

.sync-schedule-item {
  display: flex; align-items: center; justify-content: space-between;
  padding: 8px 12px; background: var(--bg); border: 1px solid var(--border);
  border-radius: var(--radius-xs); margin-bottom: 6px; font-size: 0.85rem;
}
.sync-schedule-time { font-weight: 500; display: flex; align-items: center; gap: 6px; }
.sync-schedule-time svg { width: 14px; height: 14px; color: var(--text3); }

/* Buttons Row */
.btn-row { display: flex; gap: 8px; flex-wrap: wrap; margin-top: 12px; }

/* Options */
.form-group { margin-bottom: 14px; }
.form-group label {
  display: block; font-size: 0.8rem; font-weight: 500; margin-bottom: 6px; color: var(--text2);
}
.form-group input, .form-group select, .form-group textarea {
  width: 100%; padding: 9px 12px; border: 1px solid var(--border);
  border-radius: var(--radius-xs); font-size: 0.85rem; transition: border-color var(--transition);
  background: var(--card); color: var(--text);
}
.form-group input:focus, .form-group select:focus {
  outline: none; border-color: var(--primary); box-shadow: 0 0 0 3px var(--primary-50);
}

.checkbox { display: flex; align-items: center; gap: 8px; font-size: 0.85rem; cursor: pointer; color: var(--text2); }
.checkbox input { width: 16px; height: 16px; accent-color: var(--primary); }

/* Modal */
.modal-overlay {
  display: none; position: fixed; inset: 0; background: rgba(15,23,42,0.5);
  backdrop-filter: blur(4px); z-index: 200; align-items: center; justify-content: center;
}
.modal-overlay.open { display: flex; }
.modal {
  background: var(--card); border-radius: var(--radius); width: 90%; max-width: 500px;
  max-height: 85vh; overflow-y: auto; box-shadow: 0 20px 60px rgba(0,0,0,0.15);
  border: 1px solid var(--border);
}
.modal-header {
  display: flex; justify-content: space-between; align-items: center;
  padding: 18px 24px; border-bottom: 1px solid var(--border);
}
.modal-header h3 { font-size: 1rem; font-weight: 600; display: flex; align-items: center; gap: 8px; }
.modal-close {
  background: none; border: none; cursor: pointer; color: var(--text3);
  padding: 4px; border-radius: 6px; transition: all var(--transition);
  display: flex; align-items: center; justify-content: center;
}
.modal-close:hover { background: var(--bg); color: var(--text); }
.modal-close svg { width: 18px; height: 18px; }
.modal-body { padding: 24px; }
.modal-footer { display: flex; gap: 8px; justify-content: flex-end; padding: 0 24px 20px; }

/* Auth Flow */
.modal-auth { max-width: 460px; }
.auth-flow { margin-bottom: 16px; }
.step {
  padding: 10px 14px; 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-xs) var(--radius-xs) 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); } }

/* Auth URL */
.auth-url-box {
  display: flex; flex-direction: column; gap: 10px; padding: 14px;
  background: var(--bg); border: 1px solid var(--border); border-radius: var(--radius-sm);
}
.auth-url-box label { font-size: 0.8rem; font-weight: 600; color: var(--text2); }
.auth-url-input-row { display: flex; gap: 8px; align-items: center; }
.auth-url-input {
  flex: 1; padding: 8px 10px; border: 1px solid var(--border); border-radius: var(--radius-xs);
  font-family: 'SF Mono', 'Fira Code', monospace; font-size: 0.8rem; background: var(--card);
  color: var(--text); min-width: 0;
}
.auth-url-input:focus { outline: none; border-color: var(--primary); }

.ssh-tunnel-box {
  padding: 14px; background: var(--warning-bg); border: 1px solid #fde68a;
  border-radius: var(--radius-sm); margin-bottom: 8px;
}
.ssh-tunnel-label { font-size: 0.8rem; font-weight: 600; color: #92400e; margin-bottom: 8px; display: flex; align-items: center; gap: 6px; }
.ssh-tunnel-label svg { width: 14px; height: 14px; }
.ssh-tunnel-cmd {
  display: flex; align-items: center; gap: 8px; background: var(--card);
  padding: 8px 12px; border-radius: var(--radius-xs); border: 1px solid #fde68a;
}
.ssh-tunnel-cmd code {
  flex: 1; font-family: 'SF Mono', 'Fira Code', monospace; font-size: 0.8rem;
  color: var(--text); word-break: break-all; user-select: all;
}

/* Sync Pair Modal */
.sync-pair-prefix {
  padding: 9px 12px; background: var(--bg); border: 1px solid var(--border);
  border-right: none; border-radius: var(--radius-xs) 0 0 var(--radius-xs);
  font-size: 0.82rem; font-weight: 600; color: var(--text2);
  white-space: nowrap; font-family: 'SF Mono', 'Fira Code', monospace;
}
.sync-pair-dest-input {
  flex: 1; padding: 9px 12px; border: 1px solid var(--border);
  border-radius: 0 var(--radius-xs) var(--radius-xs) 0;
  font-size: 0.85rem; font-family: 'SF Mono', 'Fira Code', monospace;
}
.sync-pair-dest-input:focus { outline: none; border-color: var(--primary); box-shadow: 0 0 0 3px var(--primary-50); }

/* Jobs */
.job-card {
  background: var(--card); border: 1px solid var(--border); border-radius: var(--radius);
  padding: 16px 20px; margin-bottom: 10px;
}
.job-card-top { display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px; }
.job-card-name { font-weight: 600; font-size: 0.9rem; display: flex; align-items: center; gap: 8px; }
.job-status {
  padding: 3px 10px; border-radius: 6px; font-size: 0.72rem; font-weight: 600; text-transform: uppercase;
  letter-spacing: 0.02em;
}
.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: 'SF Mono', 'Fira Code', monospace; font-size: 0.8rem; color: var(--text3);
  display: flex; align-items: center; gap: 8px; margin-bottom: 6px;
}
.job-card-meta { font-size: 0.75rem; color: var(--text3); }
.job-log {
  margin-top: 10px; background: #0f172a; color: #a5f3fc; border-radius: var(--radius-sm);
  padding: 12px 14px; max-height: 200px; overflow-y: auto;
}
.job-log pre {
  margin: 0; font-family: 'SF Mono', 'Fira Code', monospace; font-size: 0.78rem;
  white-space: pre-wrap; word-break: break-all; line-height: 1.5;
}

/* Toast */
.toast {
  position: fixed; bottom: 24px; right: 24px; padding: 12px 20px;
  border-radius: var(--radius-sm); color: white; font-size: 0.85rem; font-weight: 500;
  z-index: 1000; transform: translateY(100px); opacity: 0; transition: all 0.25s ease;
  display: flex; align-items: center; gap: 8px;
}
.toast svg { width: 16px; height: 16px; flex-shrink: 0; }
.toast.show { transform: translateY(0); opacity: 1; }
.toast.success { background: var(--success); }
.toast.error { background: var(--danger); }
.toast.info { background: var(--primary); }

/* Cron Info */
.cron-info-box {
  margin-top: 12px; background: #0f172a; color: #a5f3fc;
  border-radius: var(--radius-sm); padding: 14px;
  font-size: 0.8rem; overflow-x: auto; white-space: pre-wrap;
  font-family: 'SF Mono', 'Fira Code', monospace;
}

/* Responsive */
@media (max-width: 768px) {
  .app-header { padding: 0 16px; }
  .header-right { gap: 4px; }
  .btn-icon-header { padding: 6px 10px; font-size: 0.78rem; }
  .btn-icon-header .btn-label { display: none; }
  .content { padding: 20px 12px; }
  .remote-card-header { flex-direction: column; align-items: flex-start; padding: 16px; }
  .remote-card-actions { width: 100%; }
  .sync-pairs-area { padding: 0 16px 14px; }
  .sync-pair-row { flex-wrap: wrap; }
  .modal { max-width: 95%; }
}
'
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 ""
if ss -tlnp 2>/dev/null | grep -q ":${APP_PORT} " && ! pgrep -f "node server.js" >/dev/null 2>&1; then
echo "エラー: ポート${APP_PORT}は既に使用されています"
echo " 別のポートを指定してください: EASYRCLONE_PORT=3349 bash $0"
exit 1
fi
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=$APP_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}:${APP_PORT}"
fi
if [ -n "$TS_HOSTNAME" ]; then
echo " Web UI : http://${TS_HOSTNAME%%.*}:${APP_PORT} (MagicDNS)"
fi
echo " Web UI (local) : http://localhost:$APP_PORT"
echo ""
echo " サービス: systemctl [start|stop|restart|status] easyrclone"
echo " 設定ファイル: $INSTALL_DIR/config/rclone.conf"
echo " ログ: journalctl -u easyrclone -f"
echo " タイムゾーン: $(date)"
echo ""
アンインストール
一時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 ""