aethel 0.1.0

package/src/core/auth.js

@@ -0,0 +1,288 @@
+import fs from "node:fs/promises";
+import fsSyncFallback from "node:fs";
+import http from "node:http";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { URL } from "node:url";
+import { google } from "googleapis";
+import open from "open";
+
+const SCOPES = ["https://www.googleapis.com/auth/drive"];
+const DEFAULT_CREDENTIALS_PATH = "credentials.json";
+const DEFAULT_TOKEN_PATH = "token.json";
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.resolve(MODULE_DIR, "..", "..");
+const AUTH_TIMEOUT_MS = 120_000;
+
+// ── Path resolution ─────────────────────────────────────────────────
+
+function resolvePath(candidatePath, fallbackFileName) {
+  if (candidatePath) {
+    return path.isAbsolute(candidatePath)
+      ? candidatePath
+      : path.resolve(process.cwd(), candidatePath);
+  }
+  return path.join(PROJECT_ROOT, fallbackFileName);
+}
+
+export function resolveCredentialsPath(customPath) {
+  return resolvePath(
+    customPath || process.env.GOOGLE_DRIVE_CREDENTIALS_PATH,
+    DEFAULT_CREDENTIALS_PATH
+  );
+}
+
+export function resolveTokenPath(customPath) {
+  return resolvePath(
+    customPath || process.env.GOOGLE_DRIVE_TOKEN_PATH,
+    DEFAULT_TOKEN_PATH
+  );
+}
+
+// ── Credential helpers ──────────────────────────────────────────────
+
+async function loadClientConfig(credentialsPath) {
+  let raw;
+  try {
+    raw = await fs.readFile(credentialsPath, "utf8");
+  } catch {
+    throw new Error(
+      `OAuth credentials file was not found. Expected path: ${credentialsPath}`
+    );
+  }
+
+  const content = JSON.parse(raw);
+  const config = content.installed || content.web;
+
+  if (!config?.client_id || !config?.client_secret) {
+    throw new Error("OAuth credentials JSON is missing client configuration.");
+  }
+
+  return {
+    clientId: config.client_id,
+    clientSecret: config.client_secret,
+    redirectUris: config.redirect_uris || [],
+  };
+}
+
+function createOAuthClient(config, redirectUri) {
+  const fallbackRedirect =
+    config.redirectUris.find(
+      (uri) =>
+        uri.startsWith("http://localhost") || uri.startsWith("http://127.0.0.1")
+    ) ||
+    config.redirectUris[0] ||
+    "http://127.0.0.1";
+
+  return new google.auth.OAuth2(
+    config.clientId,
+    config.clientSecret,
+    redirectUri || fallbackRedirect
+  );
+}
+
+async function persistToken(tokenPath, credentials) {
+  await fs.mkdir(path.dirname(path.resolve(tokenPath)), { recursive: true });
+  await fs.writeFile(tokenPath, JSON.stringify(credentials, null, 2) + "\n");
+}
+
+function attachTokenPersistence(client, tokenPath) {
+  client.on("tokens", (tokens) => {
+    if (!tokens || Object.keys(tokens).length === 0) return;
+    persistToken(tokenPath, { ...client.credentials, ...tokens });
+  });
+}
+
+// ── Token loading & validation ──────────────────────────────────────
+
+function isTokenExpired(token) {
+  if (!token.expiry_date) return false;
+  return Date.now() >= token.expiry_date - 30_000;
+}
+
+async function loadCachedClient(config, tokenPath) {
+  let raw;
+  try {
+    raw = await fs.readFile(tokenPath, "utf8");
+  } catch {
+    return null;
+  }
+
+  const token = JSON.parse(raw);
+
+  if (!token.access_token && !token.refresh_token) {
+    return null;
+  }
+
+  const client = createOAuthClient(config);
+  attachTokenPersistence(client, tokenPath);
+  client.setCredentials(token);
+
+  // Only hit the network if the access token is expired / missing.
+  // If a refresh_token exists, googleapis will refresh automatically
+  // on the first real API call, so we can skip validation here when
+  // the token looks fresh.
+  if (token.refresh_token && !isTokenExpired(token)) {
+    return client;
+  }
+
+  try {
+    await client.getAccessToken();
+    await persistToken(tokenPath, client.credentials);
+    return client;
+  } catch (err) {
+    // Only fall through to browser auth for auth-specific errors.
+    // Network errors should propagate so the user knows what happened.
+    const status = err?.response?.status;
+    if (status === 401 || status === 403 || err?.code === "invalid_grant") {
+      return null;
+    }
+    throw err;
+  }
+}
+
+// ── Browser OAuth flow ──────────────────────────────────────────────
+
+async function runLocalServerAuth(config, tokenPath) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let oauthClient = null;
+    let timer = null;
+
+    const finish = (error, client) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      server.close(() => {
+        if (error) reject(error);
+        else resolve(client);
+      });
+    };
+
+    const server = http.createServer(async (req, res) => {
+      try {
+        if (!oauthClient) {
+          res.statusCode = 503;
+          res.end("OAuth client is not ready.");
+          return;
+        }
+
+        const requestUrl = new URL(req.url || "/", "http://127.0.0.1");
+        const code = requestUrl.searchParams.get("code");
+        const authError = requestUrl.searchParams.get("error");
+
+        if (authError) {
+          res.statusCode = 400;
+          res.end("Authentication failed. The terminal will show the error.");
+          finish(new Error(`OAuth authorization failed: ${authError}`));
+          return;
+        }
+
+        if (!code) {
+          res.statusCode = 400;
+          res.end("Authorization code is missing.");
+          return;
+        }
+
+        const { tokens } = await oauthClient.getToken(code);
+        oauthClient.setCredentials(tokens);
+        await persistToken(tokenPath, oauthClient.credentials);
+        res.end("Authentication completed. This browser tab can be closed.");
+        finish(null, oauthClient);
+      } catch (error) {
+        res.statusCode = 500;
+        res.end("Authentication failed. See the terminal for details.");
+        finish(error);
+      }
+    });
+
+    server.on("error", (error) => finish(error));
+
+    server.listen(0, "127.0.0.1", async () => {
+      try {
+        const address = server.address();
+        const port = typeof address === "object" && address ? address.port : 0;
+        const redirectUri = `http://127.0.0.1:${port}/oauth2callback`;
+
+        oauthClient = createOAuthClient(config, redirectUri);
+        attachTokenPersistence(oauthClient, tokenPath);
+
+        const authUrl = oauthClient.generateAuthUrl({
+          access_type: "offline",
+          prompt: "consent",
+          scope: SCOPES,
+        });
+
+        console.log("Opening browser for Google OAuth...");
+        console.log(`If the browser does not open, visit:\n${authUrl}`);
+        await open(authUrl).catch(() => undefined);
+
+        timer = setTimeout(() => {
+          finish(
+            new Error(
+              `OAuth timed out after ${AUTH_TIMEOUT_MS / 1000}s. Re-run 'aethel auth' to retry.`
+            )
+          );
+        }, AUTH_TIMEOUT_MS);
+      } catch (error) {
+        finish(error);
+      }
+    });
+  });
+}
+
+// ── Singleton auth manager ──────────────────────────────────────────
+
+let _authPromise = null;
+let _authKey = null;
+
+function authCacheKey(credentialsPath, tokenPath) {
+  return `${credentialsPath}\0${tokenPath}`;
+}
+
+/**
+ * Return an authenticated OAuth2 client.  Concurrent callers with the
+ * same credential+token paths share a single in-flight auth attempt,
+ * preventing duplicate browser prompts and token-refresh races.
+ */
+export async function getAuthClient(credentialsPath, tokenPath) {
+  const resolvedCredentials = resolveCredentialsPath(credentialsPath);
+  const resolvedToken = resolveTokenPath(tokenPath);
+  const key = authCacheKey(resolvedCredentials, resolvedToken);
+
+  if (_authPromise && _authKey === key) {
+    return _authPromise;
+  }
+
+  _authKey = key;
+  _authPromise = (async () => {
+    const config = await loadClientConfig(resolvedCredentials);
+    const cached = await loadCachedClient(config, resolvedToken);
+    return cached || (await runLocalServerAuth(config, resolvedToken));
+  })();
+
+  try {
+    return await _authPromise;
+  } catch {
+    // Clear the cache on failure so the next call retries.
+    _authPromise = null;
+    _authKey = null;
+    throw arguments[0];
+  }
+}
+
+/** Clear the singleton so the next call re-authenticates. */
+export function resetAuth() {
+  _authPromise = null;
+  _authKey = null;
+}
+
+/**
+ * High-level entry point: returns a googleapis drive client.
+ * Kept for backwards compatibility — prefer getAuthClient + google.drive
+ * for finer control.
+ */
+export async function authenticate(credentialsPath, tokenPath) {
+  const authClient = await getAuthClient(credentialsPath, tokenPath);
+  return google.drive({ version: "v3", auth: authClient });
+}

package/src/core/config.js

@@ -0,0 +1,117 @@
+/**
+ * .aethel/ directory management, configuration, and state persistence.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+export const AETHEL_DIR = ".aethel";
+export const CONFIG_FILE = "config.json";
+export const INDEX_FILE = "index.json";
+export const SNAPSHOTS_DIR = "snapshots";
+export const HISTORY_DIR = "history";
+export const LATEST_SNAPSHOT = "latest.json";
+
+/** Walk up from `start` looking for a .aethel/ directory. */
+export function findRoot(start = process.cwd()) {
+  let p = path.resolve(start);
+  while (true) {
+    if (fs.existsSync(path.join(p, AETHEL_DIR))) return p;
+    const parent = path.dirname(p);
+    if (parent === p) return null;
+    p = parent;
+  }
+}
+
+/** Return the workspace root or throw. */
+export function requireRoot(start) {
+  const root = findRoot(start);
+  if (!root) {
+    throw new Error(
+      "Not an Aethel workspace (no .aethel/ found). Run 'aethel init' first."
+    );
+  }
+  return root;
+}
+
+function dot(root) {
+  return path.join(root, AETHEL_DIR);
+}
+
+/** Create a fresh .aethel/ workspace. Returns the root path. */
+export function initWorkspace(localPath, driveFolderId = null, driveFolderName = "My Drive") {
+  const root = path.resolve(localPath);
+  const d = dot(root);
+
+  if (fs.existsSync(d)) {
+    throw new Error(`Workspace already initialised at ${d}`);
+  }
+
+  fs.mkdirSync(d, { recursive: true });
+  fs.mkdirSync(path.join(d, SNAPSHOTS_DIR));
+  fs.mkdirSync(path.join(d, SNAPSHOTS_DIR, HISTORY_DIR));
+
+  const config = {
+    version: 1,
+    drive_folder_id: driveFolderId,
+    drive_folder_name: driveFolderName,
+    local_path: root,
+  };
+
+  writeConfig(root, config);
+  writeIndex(root, { staged: [] });
+  return root;
+}
+
+// ── config helpers ───────────────────────────────────────────────────
+
+export function readConfig(root) {
+  return JSON.parse(fs.readFileSync(path.join(dot(root), CONFIG_FILE), "utf-8"));
+}
+
+export function writeConfig(root, data) {
+  fs.writeFileSync(
+    path.join(dot(root), CONFIG_FILE),
+    JSON.stringify(data, null, 2) + "\n"
+  );
+}
+
+// ── index (staging area) helpers ─────────────────────────────────────
+
+export function readIndex(root) {
+  const p = path.join(dot(root), INDEX_FILE);
+  if (!fs.existsSync(p)) return { staged: [] };
+  return JSON.parse(fs.readFileSync(p, "utf-8"));
+}
+
+export function writeIndex(root, data) {
+  fs.writeFileSync(
+    path.join(dot(root), INDEX_FILE),
+    JSON.stringify(data, null, 2) + "\n"
+  );
+}
+
+// ── snapshot helpers ─────────────────────────────────────────────────
+
+export function latestSnapshotPath(root) {
+  return path.join(dot(root), SNAPSHOTS_DIR, LATEST_SNAPSHOT);
+}
+
+export function readLatestSnapshot(root) {
+  const p = latestSnapshotPath(root);
+  if (!fs.existsSync(p)) return null;
+  return JSON.parse(fs.readFileSync(p, "utf-8"));
+}
+
+export function writeSnapshot(root, snapshot) {
+  const snapDir = path.join(dot(root), SNAPSHOTS_DIR);
+  const latest = path.join(snapDir, LATEST_SNAPSHOT);
+
+  // Archive previous latest
+  if (fs.existsSync(latest)) {
+    const ts = new Date().toISOString().replace(/[:-]/g, "").replace(/\.\d+Z/, "Z");
+    fs.copyFileSync(latest, path.join(snapDir, HISTORY_DIR, `${ts}.json`));
+  }
+
+  fs.writeFileSync(latest, JSON.stringify(snapshot, null, 2) + "\n");
+}

package/src/core/diff.js

@@ -0,0 +1,254 @@
+import { isWorkspaceType } from "./drive-api.js";
+import { loadIgnoreRules } from "./ignore.js";
+
+export const ChangeType = Object.freeze({
+  REMOTE_ADDED: "remote_added",
+  REMOTE_MODIFIED: "remote_modified",
+  REMOTE_DELETED: "remote_deleted",
+  LOCAL_ADDED: "local_added",
+  LOCAL_MODIFIED: "local_modified",
+  LOCAL_DELETED: "local_deleted",
+  CONFLICT: "conflict",
+});
+
+const SHORT_STATUS = {
+  [ChangeType.REMOTE_ADDED]: "+R",
+  [ChangeType.REMOTE_MODIFIED]: "MR",
+  [ChangeType.REMOTE_DELETED]: "-R",
+  [ChangeType.LOCAL_ADDED]: "+L",
+  [ChangeType.LOCAL_MODIFIED]: "ML",
+  [ChangeType.LOCAL_DELETED]: "-L",
+  [ChangeType.CONFLICT]: "!!",
+};
+
+const DESCRIPTION = {
+  [ChangeType.REMOTE_ADDED]: "new on Drive",
+  [ChangeType.REMOTE_MODIFIED]: "modified on Drive",
+  [ChangeType.REMOTE_DELETED]: "deleted on Drive",
+  [ChangeType.LOCAL_ADDED]: "new locally",
+  [ChangeType.LOCAL_MODIFIED]: "modified locally",
+  [ChangeType.LOCAL_DELETED]: "deleted locally",
+  [ChangeType.CONFLICT]: "both sides changed",
+};
+
+const SUGGESTED_ACTION = {
+  [ChangeType.REMOTE_ADDED]: "download",
+  [ChangeType.REMOTE_MODIFIED]: "download",
+  [ChangeType.REMOTE_DELETED]: "delete_local",
+  [ChangeType.LOCAL_ADDED]: "upload",
+  [ChangeType.LOCAL_MODIFIED]: "upload",
+  [ChangeType.LOCAL_DELETED]: "delete_remote",
+  [ChangeType.CONFLICT]: "conflict",
+};
+
+function createChange({
+  changeType,
+  path,
+  fileId = null,
+  remoteMeta = null,
+  localMeta = null,
+  snapshotMeta = null,
+}) {
+  return {
+    changeType,
+    path,
+    fileId,
+    remoteMeta,
+    localMeta,
+    snapshotMeta,
+    shortStatus: SHORT_STATUS[changeType],
+    description: DESCRIPTION[changeType],
+    suggestedAction: SUGGESTED_ACTION[changeType],
+  };
+}
+
+function buildDiffResult(changes) {
+  return {
+    changes,
+    get remoteChanges() {
+      return this.changes.filter((change) =>
+        change.changeType.startsWith("remote")
+      );
+    },
+    get localChanges() {
+      return this.changes.filter((change) =>
+        change.changeType.startsWith("local")
+      );
+    },
+    get conflicts() {
+      return this.changes.filter(
+        (change) => change.changeType === ChangeType.CONFLICT
+      );
+    },
+    get isClean() {
+      return this.changes.length === 0;
+    },
+  };
+}
+
+function remoteChanged(snapshotEntry, remoteEntry) {
+  if (isWorkspaceType(remoteEntry.mimeType || "")) {
+    return snapshotEntry.modifiedTime !== remoteEntry.modifiedTime;
+  }
+
+  return snapshotEntry.md5Checksum !== remoteEntry.md5Checksum;
+}
+
+function localChanged(snapshotEntry, localEntry) {
+  return snapshotEntry.md5 !== localEntry.md5;
+}
+
+function promoteConflicts(changes) {
+  const remoteByPath = new Map();
+  const localByPath = new Map();
+
+  for (const change of changes) {
+    if (change.changeType.startsWith("remote")) {
+      remoteByPath.set(change.path, change);
+      continue;
+    }
+
+    if (change.changeType.startsWith("local")) {
+      localByPath.set(change.path, change);
+    }
+  }
+
+  const conflictPathSet = new Set();
+  for (const pathValue of remoteByPath.keys()) {
+    if (localByPath.has(pathValue)) {
+      conflictPathSet.add(pathValue);
+    }
+  }
+
+  if (conflictPathSet.size === 0) {
+    return changes;
+  }
+
+  const filtered = changes.filter(
+    (change) => !conflictPathSet.has(change.path)
+  );
+
+  for (const pathValue of [...conflictPathSet].sort()) {
+    const remoteChange = remoteByPath.get(pathValue);
+    const localChange = localByPath.get(pathValue);
+
+    filtered.push(
+      createChange({
+        changeType: ChangeType.CONFLICT,
+        path: pathValue,
+        fileId: remoteChange.fileId,
+        remoteMeta: remoteChange.remoteMeta,
+        localMeta: localChange.localMeta,
+        snapshotMeta: remoteChange.snapshotMeta || localChange.snapshotMeta,
+      })
+    );
+  }
+
+  return filtered;
+}
+
+/**
+ * @param {object|null} snapshot
+ * @param {object[]} remoteFiles
+ * @param {object} localFiles
+ * @param {{ root?: string, respectIgnore?: boolean }} options
+ */
+export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIgnore = true } = {}) {
+  const ignoreRules = root && respectIgnore ? loadIgnoreRules(root) : null;
+
+  // Pre-filter remote files by ignore rules
+  if (ignoreRules) {
+    remoteFiles = remoteFiles.filter((f) => !ignoreRules.ignores(f.path));
+  }
+  const changes = [];
+  const snapshotFiles = snapshot?.files || {};
+  const snapshotLocalFiles = snapshot?.localFiles || {};
+  const snapshotById = new Map();
+
+  for (const [fileId, meta] of Object.entries(snapshotFiles)) {
+    snapshotById.set(fileId, meta);
+  }
+
+  const remoteById = new Map(remoteFiles.map((file) => [file.id, file]));
+
+  for (const remoteFile of remoteFiles) {
+    const snapshotEntry = snapshotById.get(remoteFile.id);
+
+    if (!snapshotEntry) {
+      changes.push(
+        createChange({
+          changeType: ChangeType.REMOTE_ADDED,
+          path: remoteFile.path,
+          fileId: remoteFile.id,
+          remoteMeta: remoteFile,
+        })
+      );
+      continue;
+    }
+
+    if (remoteChanged(snapshotEntry, remoteFile)) {
+      changes.push(
+        createChange({
+          changeType: ChangeType.REMOTE_MODIFIED,
+          path: remoteFile.path,
+          fileId: remoteFile.id,
+          remoteMeta: remoteFile,
+          snapshotMeta: snapshotEntry,
+        })
+      );
+    }
+  }
+
+  for (const [fileId, snapshotEntry] of snapshotById.entries()) {
+    if (!remoteById.has(fileId)) {
+      changes.push(
+        createChange({
+          changeType: ChangeType.REMOTE_DELETED,
+          path: snapshotEntry.path || snapshotEntry.localPath || "",
+          fileId,
+          snapshotMeta: snapshotEntry,
+        })
+      );
+    }
+  }
+
+  for (const [relativePath, localMeta] of Object.entries(localFiles)) {
+    const snapshotEntry = snapshotLocalFiles[relativePath];
+
+    if (!snapshotEntry) {
+      changes.push(
+        createChange({
+          changeType: ChangeType.LOCAL_ADDED,
+          path: relativePath,
+          localMeta,
+        })
+      );
+      continue;
+    }
+
+    if (localChanged(snapshotEntry, localMeta)) {
+      changes.push(
+        createChange({
+          changeType: ChangeType.LOCAL_MODIFIED,
+          path: relativePath,
+          localMeta,
+          snapshotMeta: snapshotEntry,
+        })
+      );
+    }
+  }
+
+  for (const [relativePath, snapshotEntry] of Object.entries(snapshotLocalFiles)) {
+    if (!(relativePath in localFiles)) {
+      changes.push(
+        createChange({
+          changeType: ChangeType.LOCAL_DELETED,
+          path: relativePath,
+          snapshotMeta: snapshotEntry,
+        })
+      );
+    }
+  }
+
+  return buildDiffResult(promoteConflicts(changes));
+}