ikanban-web 0.1.1

package/server/lib/cloudflare-tunnel.js

@@ -0,0 +1,196 @@
+import { spawn, spawnSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const TRY_CF_URL_REGEX = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
+
+async function searchPathFor(command) {
+  const pathValue = process.env.PATH || '';
+  const segments = pathValue.split(path.delimiter).filter(Boolean);
+  const WINDOWS_EXTENSIONS = process.platform === 'win32'
+    ? (process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM')
+        .split(';')
+        .map((ext) => ext.trim().toLowerCase())
+        .filter(Boolean)
+        .map((ext) => (ext.startsWith('.') ? ext : `.${ext}`))
+    : [''];
+
+  for (const dir of segments) {
+    for (const ext of WINDOWS_EXTENSIONS) {
+      const fileName = process.platform === 'win32' ? `${command}${ext}` : command;
+      const candidate = path.join(dir, fileName);
+      try {
+        const stats = fs.statSync(candidate);
+        if (stats.isFile()) {
+          if (process.platform !== 'win32') {
+            try {
+              fs.accessSync(candidate, fs.constants.X_OK);
+            } catch {
+              continue;
+            }
+          }
+          return candidate;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+
+export async function checkCloudflaredAvailable() {
+  const cfPath = await searchPathFor('cloudflared');
+  if (cfPath) {
+    try {
+      const result = spawnSync(cfPath, ['--version'], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+      if (result.status === 0) {
+        return { available: true, path: cfPath, version: result.stdout.trim() };
+      }
+    } catch {
+      // Ignore
+    }
+  }
+  return { available: false, path: null, version: null };
+}
+
+export function printCloudflareTunnelInstallHelp() {
+  const platform = process.platform;
+  let installCmd = '';
+
+  if (platform === 'darwin') {
+    installCmd = 'brew install cloudflared';
+  } else if (platform === 'win32') {
+    installCmd = 'winget install --id Cloudflare.cloudflared';
+  } else {
+    installCmd = 'Download from https://github.com/cloudflare/cloudflared/releases';
+  }
+
+  console.log(`
+╔══════════════════════════════════════════════════════════════════╗
+║  Cloudflare tunnel requires 'cloudflared' to be installed        ║
+╚══════════════════════════════════════════════════════════════════╝
+
+Install instructions for your platform:
+
+  macOS:    brew install cloudflared
+  Windows:  winget install --id Cloudflare.cloudflared
+  Linux:    Download from https://github.com/cloudflare/cloudflared/releases
+
+Or visit: https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflared/downloads/
+`);
+}
+
+export async function startCloudflareTunnel({ originUrl, port }) {
+  const cfCheck = await checkCloudflaredAvailable();
+
+  if (!cfCheck.available) {
+    printCloudflareTunnelInstallHelp();
+    throw new Error('cloudflared is not installed');
+  }
+
+  console.log(`Using cloudflared: ${cfCheck.path} (${cfCheck.version})`);
+
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ikanban-cf-'));
+
+  const child = spawn('cloudflared', ['tunnel', '--url', originUrl], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: {
+      ...process.env,
+      HOME: tempDir,
+      CF_TELEMETRY_DISABLE: '1',
+    },
+    killSignal: 'SIGINT',
+  });
+
+  let publicUrl = null;
+  let tunnelReady = false;
+
+  const onData = (chunk, isStderr) => {
+    const text = chunk.toString('utf8');
+
+    if (!tunnelReady) {
+      const match = text.match(TRY_CF_URL_REGEX);
+      if (match) {
+        publicUrl = match[0];
+        tunnelReady = true;
+      }
+    }
+
+    process.stderr.write(isStderr ? text : '');
+  };
+
+  child.stdout.on('data', (chunk) => onData(chunk, false));
+  child.stderr.on('data', (chunk) => onData(chunk, true));
+
+  child.on('error', (error) => {
+    console.error(`Cloudflared error: ${error.message}`);
+    cleanupTempDir();
+  });
+
+  const cleanupTempDir = () => {
+    try {
+      if (fs.existsSync(tempDir)) {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      }
+    } catch {
+      // Ignore cleanup errors
+    }
+  };
+
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      if (!publicUrl) {
+        reject(new Error('Tunnel URL not received within 30 seconds'));
+      }
+    }, 30000);
+
+    const checkReady = setInterval(() => {
+      if (publicUrl) {
+        clearTimeout(timeout);
+        clearInterval(checkReady);
+        resolve(null);
+      }
+    }, 100);
+
+    child.on('exit', (code) => {
+      clearTimeout(timeout);
+      clearInterval(checkReady);
+      cleanupTempDir();
+      if (code !== null && code !== 0) {
+        reject(new Error(`Cloudflared exited with code ${code}`));
+      }
+    });
+  });
+
+  return {
+    stop: () => {
+      try {
+        child.kill('SIGINT');
+      } catch {
+        // Ignore
+      }
+    },
+    process: child,
+    getPublicUrl: () => publicUrl,
+  };
+}
+
+export function printTunnelWarning() {
+  console.log(`
+⚠️  Cloudflare Quick Tunnel Limitations:
+
+   • Maximum 200 concurrent requests
+   • Server-Sent Events (SSE) are NOT supported
+   • URLs are temporary and will expire when the tunnel stops
+   • Password protection is required for tunnel access
+
+   For production use, set up a named Cloudflare Tunnel:
+   https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/
+`);
+}

package/server/lib/git-credentials.js

@@ -0,0 +1,74 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const GIT_CREDENTIALS_PATH = path.join(os.homedir(), '.git-credentials');
+
+export function discoverGitCredentials() {
+  const credentials = [];
+
+  if (!fs.existsSync(GIT_CREDENTIALS_PATH)) {
+    return credentials;
+  }
+
+  try {
+    const content = fs.readFileSync(GIT_CREDENTIALS_PATH, 'utf8');
+    const lines = content.split('\n').filter(line => line.trim());
+
+    for (const line of lines) {
+      try {
+        const url = new URL(line.trim());
+        const hostname = url.hostname;
+        const pathname = url.pathname && url.pathname !== '/' ? url.pathname : '';
+        const host = hostname + pathname;
+        const username = url.username || '';
+
+        if (host && username) {
+          const exists = credentials.some(c => c.host === host && c.username === username);
+          if (!exists) {
+            credentials.push({ host, username });
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch (error) {
+    console.error('Failed to read .git-credentials:', error);
+  }
+
+  return credentials;
+}
+
+export function getCredentialForHost(host) {
+  if (!fs.existsSync(GIT_CREDENTIALS_PATH)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(GIT_CREDENTIALS_PATH, 'utf8');
+    const lines = content.split('\n').filter(line => line.trim());
+
+    for (const line of lines) {
+      try {
+        const url = new URL(line.trim());
+        const hostname = url.hostname;
+        const pathname = url.pathname && url.pathname !== '/' ? url.pathname : '';
+        const credHost = hostname + pathname;
+
+        if (credHost === host) {
+          return {
+            username: url.username || '',
+            token: url.password || ''
+          };
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch (error) {
+    console.error('Failed to read .git-credentials for host lookup:', error);
+  }
+
+  return null;
+}

package/server/lib/git-identity-storage.js

@@ -0,0 +1,110 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const STORAGE_DIR = path.join(os.homedir(), '.config', 'ikanban');
+const STORAGE_FILE = path.join(STORAGE_DIR, 'git-identities.json');
+
+function ensureStorageDir() {
+  if (!fs.existsSync(STORAGE_DIR)) {
+    fs.mkdirSync(STORAGE_DIR, { recursive: true });
+  }
+}
+
+export function loadProfiles() {
+  ensureStorageDir();
+
+  if (!fs.existsSync(STORAGE_FILE)) {
+    return { profiles: [] };
+  }
+
+  try {
+    const content = fs.readFileSync(STORAGE_FILE, 'utf8');
+    const data = JSON.parse(content);
+    return data;
+  } catch (error) {
+    console.error('Failed to load git identity profiles:', error);
+    return { profiles: [] };
+  }
+}
+
+export function saveProfiles(data) {
+  ensureStorageDir();
+
+  try {
+    fs.writeFileSync(STORAGE_FILE, JSON.stringify(data, null, 2), 'utf8');
+    return true;
+  } catch (error) {
+    console.error('Failed to save git identity profiles:', error);
+    throw error;
+  }
+}
+
+export function getProfiles() {
+  const data = loadProfiles();
+  return data.profiles || [];
+}
+
+export function getProfile(id) {
+  const profiles = getProfiles();
+  return profiles.find(p => p.id === id) || null;
+}
+
+export function createProfile(profileData) {
+  const profiles = getProfiles();
+
+  if (profiles.some(p => p.id === profileData.id)) {
+    throw new Error(`Profile with ID "${profileData.id}" already exists`);
+  }
+
+  if (!profileData.id || !profileData.userName || !profileData.userEmail) {
+    throw new Error('Profile must have id, userName, and userEmail');
+  }
+
+  const newProfile = {
+    id: profileData.id,
+    name: profileData.name || profileData.userName,
+    userName: profileData.userName,
+    userEmail: profileData.userEmail,
+    authType: profileData.authType || 'ssh',
+    sshKey: profileData.sshKey || null,
+    host: profileData.host || null,
+    color: profileData.color || 'keyword',
+    icon: profileData.icon || 'branch'
+  };
+
+  profiles.push(newProfile);
+  saveProfiles({ profiles });
+
+  return newProfile;
+}
+
+export function updateProfile(id, updates) {
+  const profiles = getProfiles();
+  const index = profiles.findIndex(p => p.id === id);
+
+  if (index === -1) {
+    throw new Error(`Profile with ID "${id}" not found`);
+  }
+
+  profiles[index] = {
+    ...profiles[index],
+    ...updates,
+    id: profiles[index].id
+  };
+
+  saveProfiles({ profiles });
+  return profiles[index];
+}
+
+export function deleteProfile(id) {
+  const profiles = getProfiles();
+  const filteredProfiles = profiles.filter(p => p.id !== id);
+
+  if (filteredProfiles.length === profiles.length) {
+    throw new Error(`Profile with ID "${id}" not found`);
+  }
+
+  saveProfiles({ profiles: filteredProfiles });
+  return true;
+}