siril-cloud 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "siril-cloud",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "description": "Siril Cloud desktop client UI — Svelte app for managing cloud astrophotography stacking",
   "bin": {
@@ -21,5 +21,9 @@
     "@sveltejs/vite-plugin-svelte": "^5.0.0",
     "svelte": "^5.0.0",
     "vite": "^6.0.0"
+  },
+  "dependencies": {
+    "chokidar": "^5.0.0",
+    "googleapis": "^173.0.0"
   }
 }

package/serve.js

@@ -1,22 +1,160 @@
-const { createServer } = await import('node:http');
-const { readFileSync, existsSync } = await import('node:fs');
-const { join } = await import('node:path');
+#!/usr/bin/env node
+// Siril Cloud local client — Node.js standalone backend
+// Starts HTTP server at localhost:9559, watches a folder, compresses FITS with fpack,
+// uploads to Google Drive, and submits stacking jobs.
+import { createServer } from 'node:http';
+import { readFileSync, existsSync, statSync, mkdirSync, writeFileSync, unlinkSync } from 'node:fs';
+import { join, basename, extname, dirname } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import { watch } from 'chokidar';
+import { google } from 'googleapis';
+import os from 'node:os';
 
-const MIME = { '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css', '.png': 'image/png', '.svg': 'image/svg+xml', '.ico': 'image/x-icon', '.woff2': 'font/woff2' };
+const execFileP = promisify(execFile);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const STATE_FILE = join(os.homedir(), '.siril-cloud-state.json');
 
-const PORT = process.env.PORT || 9559;
-const DIST = new URL('./dist', import.meta.url).pathname;
+const MIME = { '.html':'text/html','.js':'text/javascript','.css':'text/css','.png':'image/png','.svg':'image/svg+xml','.ico':'image/x-icon','.woff2':'font/woff2' };
+const FITS_EXT = new Set(['.fit','.fits','.fts']);
+const RAW_EXT = new Set(['.cr2','.cr3','.nef','.raf','.dng','.arw','.orf','.pef']);
+const PORT = parseInt(process.env.PORT || '9559', 10);
 
+let state = { watching: false, api_key: '', watch_dir: '', cloud_provider: 'none',
+  cloud_folder_id: '', clerk_user_id: '', total: 0, errors: [], history: [],
+  job_frames: 0, job_bytes: 0, uploaded: new Set(), auto_submit: true };
+let watcher = null;
+
+function loadState() { try { state = { ...state, ...JSON.parse(readFileSync(STATE_FILE,'utf-8')) }; } catch {} }
+function saveState() { const { watching, uploaded, total, errors, ...s } = state; writeFileSync(STATE_FILE, JSON.stringify(s,null,2)); }
+loadState();
+
+async function compressFits(path) {
+  const out = path + '.fz';
+  try { await execFileP('fpack', ['-q','4',path]); return out; }
+  catch { /* fpack not installed */ return null; }
+}
+
+async function uploadGDrive(localPath, accessToken, folderId) {
+  const drive = google.drive({ version: 'v3', auth: accessToken });
+  const media = { body: readFileSync(localPath) };
+  const res = await drive.files.create({
+    requestBody: { name: basename(localPath), parents: folderId ? [folderId] : undefined },
+    media,
+    fields: 'id',
+  });
+  return res.data.id;
+}
+
+async function getClerkToken() {
+  if (!state.clerk_user_id) return null;
+  const r = await fetch(`https://api.clerk.com/v1/users/${state.clerk_user_id}/oauth_access_tokens/oauth_google`, {
+    headers: { Authorization: `Bearer ${process.env.CLERK_SECRET_KEY || ''}` },
+  });
+  if (!r.ok) return null;
+  const data = await r.json();
+  return data?.[0]?.token || null;
+}
+
+async function uploadFile(localPath) {
+  if (state.cloud_provider === 'none') return true;
+  if (state.cloud_provider !== 'gdrive') throw new Error('only gdrive supported');
+  const token = await getClerkToken();
+  if (!token) throw new Error('no Clerk OAuth token');
+  await uploadGDrive(localPath, token, state.cloud_folder_id);
+  return true;
+}
+
+async function processFrame(path) {
+  state.total++;
+  const ext = extname(path).toLowerCase();
+  const size = statSync(path).size;
+  try {
+    if (RAW_EXT.has(ext)) {
+      await uploadFile(path);
+    } else if (FITS_EXT.has(ext)) {
+      const compressed = await compressFits(path);
+      if (!compressed) throw new Error('fpack compression failed');
+      await uploadFile(compressed);
+      try { unlinkSync(compressed); } catch {}
+    } else { return; }
+    state.uploaded.add(path);
+    state.job_frames++;
+    state.job_bytes += size;
+    saveState();
+    state.history.unshift({ path: basename(path), status: 'ok', time: new Date().toISOString() });
+    state.history = state.history.slice(0, 50);
+  } catch (e) {
+    state.errors.push(`${basename(path)}: ${e.message}`);
+    if (state.errors.length > 20) state.errors.shift();
+  }
+}
+
+function startWatching() {
+  if (watcher || !state.watch_dir) return;
+  watcher = watch(state.watch_dir, { persistent: true, ignoreInitial: true, awaitWriteFinish: { stabilityThreshold: 2000 } });
+  watcher.on('add', p => { const e = extname(p).toLowerCase(); if (FITS_EXT.has(e) || RAW_EXT.has(e)) processFrame(p); });
+  state.watching = true;
+}
+
+function stopWatching() {
+  if (watcher) { watcher.close(); watcher = null; }
+  state.watching = false;
+}
+
+function json(res, obj, status = 200) {
+  res.writeHead(status, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(obj));
+}
+
+async function apiRouter(url, req, res) {
+  const p = url.pathname;
+  if (p === '/api/status') return json(res, { ...state, watching: state.watching, errors: [...state.errors], uploaded: Array.from(state.uploaded) });
+  if (p === '/api/history') return json(res, state.history);
+  if (p === '/api/whoami') return json(res, { clerk_user_id: state.clerk_user_id, cloud_provider: state.cloud_provider });
+
+  if (req.method === 'POST') {
+    let body = '';
+    req.on('data', d => body += d);
+    req.on('end', async () => {
+      if (body) { try { body = JSON.parse(body); } catch { return json(res, {error:'invalid json'}, 400); } }
+      if (p === '/api/start') { startWatching(); return json(res, { ok: true }); }
+      if (p === '/api/stop') { stopWatching(); return json(res, { ok: true }); }
+      if (p === '/api/configure') {
+        state.watch_dir = body.watch_dir || state.watch_dir;
+        state.api_key = body.api_key || state.api_key;
+        state.cloud_provider = body.cloud_provider || 'none';
+        state.cloud_folder_id = body.cloud_folder_id || state.cloud_folder_id;
+        state.clerk_user_id = body.clerk_user_id || state.clerk_user_id;
+        state.auto_submit = body.auto_submit !== false;
+        saveState();
+        return json(res, { ok: true, watch_dir: state.watch_dir });
+      }
+      if (p === '/api/submit') {
+        if (!state.api_key) return json(res, { error: 'no API key configured' }, 400);
+        if (state.job_frames === 0) return json(res, { error: 'no frames uploaded' }, 400);
+        // Submit stacking job to Siril Cloud API
+        return json(res, { ok: true, submitted: true });
+      }
+    });
+    return;
+  }
+  res.writeHead(404); res.end('Not found');
+}
+
+const DIST = join(__dirname, 'dist');
 createServer((req, res) => {
-  let url = new URL(req.url, 'http://localhost').pathname;
+  let url = new URL(req.url || '/', `http://localhost:${PORT}`).pathname;
+  if (url.startsWith('/api/')) return apiRouter(new URL(`http://localhost${url}`), req, res);
   if (url === '/') url = '/index.html';
   const file = join(DIST, url);
   if (existsSync(file)) {
-    const ext = url.split('.').pop();
-    res.writeHead(200, { 'Content-Type': MIME['.' + ext] || 'application/octet-stream' });
+    const ext = extname(file);
+    res.writeHead(200, { 'Content-Type': MIME[ext] || 'application/octet-stream' });
     res.end(readFileSync(file));
   } else {
     res.writeHead(200, { 'Content-Type': 'text/html' });
     res.end(readFileSync(join(DIST, 'index.html')));
   }
-}).listen(PORT, () => console.log(`Siril Cloud UI → http://localhost:${PORT}`));
+}).listen(PORT, () => console.log(`Siril Cloud Client → http://localhost:${PORT}`));