@remixhq/core 0.1.2

package/dist/chunk-5NTOJXEZ.js

@@ -0,0 +1,223 @@
+import {
+  ComergeError
+} from "./chunk-K57ZFDGC.js";
+
+// src/auth/session.ts
+import { z } from "zod";
+var storedSessionSchema = z.object({
+  access_token: z.string().min(1),
+  refresh_token: z.string().min(1),
+  expires_at: z.number().int().positive(),
+  token_type: z.string().min(1).optional(),
+  user: z.object({
+    id: z.string().min(1),
+    email: z.string().email().optional().nullable()
+  }).optional()
+});
+
+// src/auth/localSessionStore.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+function xdgConfigHome() {
+  const value = process.env.XDG_CONFIG_HOME;
+  if (typeof value === "string" && value.trim()) return value;
+  return path.join(os.homedir(), ".config");
+}
+async function maybeLoadKeytar() {
+  try {
+    const mod = await new Function("return import('keytar')")();
+    const candidates = [mod, mod?.default].filter(Boolean);
+    for (const candidate of candidates) {
+      const value = candidate;
+      if (typeof value.getPassword === "function" && typeof value.setPassword === "function") {
+        return value;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function ensurePathPermissions(filePath) {
+  const dir = path.dirname(filePath);
+  await fs.mkdir(dir, { recursive: true });
+  try {
+    await fs.chmod(dir, 448);
+  } catch {
+  }
+  try {
+    await fs.chmod(filePath, 384);
+  } catch {
+  }
+}
+async function writeJsonAtomic(filePath, value) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  await fs.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  await fs.rename(tmpPath, filePath);
+}
+async function writeSessionFileFallback(filePath, session) {
+  await writeJsonAtomic(filePath, session);
+  await ensurePathPermissions(filePath);
+}
+function createLocalSessionStore(params) {
+  const service = params?.service?.trim() || "comerge-cli";
+  const account = params?.account?.trim() || "default";
+  const filePath = params?.filePath?.trim() || path.join(xdgConfigHome(), "comerge", "session.json");
+  return {
+    async getSession() {
+      const keytar = await maybeLoadKeytar();
+      if (keytar) {
+        const raw2 = await keytar.getPassword(service, account);
+        if (!raw2) return null;
+        try {
+          const parsed = storedSessionSchema.safeParse(JSON.parse(raw2));
+          return parsed.success ? parsed.data : null;
+        } catch {
+          return null;
+        }
+      }
+      const raw = await fs.readFile(filePath, "utf8").catch(() => null);
+      if (!raw) return null;
+      try {
+        const parsed = storedSessionSchema.safeParse(JSON.parse(raw));
+        if (!parsed.success) return null;
+        await ensurePathPermissions(filePath);
+        return parsed.data;
+      } catch {
+        return null;
+      }
+    },
+    async setSession(session) {
+      const parsed = storedSessionSchema.safeParse(session);
+      if (!parsed.success) {
+        throw new Error("Session data is invalid and was not stored.");
+      }
+      const keytar = await maybeLoadKeytar();
+      if (keytar) {
+        await keytar.setPassword(service, account, JSON.stringify(parsed.data));
+      }
+      await writeSessionFileFallback(filePath, parsed.data);
+    }
+  };
+}
+
+// src/auth/tokenProvider.ts
+function shouldRefreshSoon(session, skewSeconds = 60) {
+  const nowSec = Math.floor(Date.now() / 1e3);
+  return session.expires_at <= nowSec + skewSeconds;
+}
+function createStoredSessionTokenProvider(params) {
+  return async (opts) => {
+    const forceRefresh = Boolean(opts?.forceRefresh);
+    const envToken = process.env.COMERGE_ACCESS_TOKEN;
+    if (typeof envToken === "string" && envToken.trim().length > 0) {
+      return { token: envToken.trim(), session: null, fromEnv: true };
+    }
+    let session = await params.sessionStore.getSession();
+    if (!session) {
+      throw new ComergeError("Not signed in.", {
+        exitCode: 2,
+        hint: "Run `comerge login`, or set COMERGE_ACCESS_TOKEN for CI."
+      });
+    }
+    if (forceRefresh || shouldRefreshSoon(session)) {
+      try {
+        session = await params.refreshStoredSession({ config: params.config, session });
+        await params.sessionStore.setSession(session);
+      } catch (err) {
+        void err;
+      }
+    }
+    return { token: session.access_token, session, fromEnv: false };
+  };
+}
+
+// src/auth/supabase.ts
+import { createClient } from "@supabase/supabase-js";
+function createInMemoryStorage() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    getItem: (k) => map.get(k) ?? null,
+    setItem: (k, v) => {
+      map.set(k, v);
+    },
+    removeItem: (k) => {
+      map.delete(k);
+    }
+  };
+}
+function createSupabaseClient(config, storage) {
+  return createClient(config.supabaseUrl, config.supabaseAnonKey, {
+    auth: {
+      flowType: "pkce",
+      persistSession: false,
+      autoRefreshToken: false,
+      detectSessionInUrl: false,
+      storage
+    },
+    global: {
+      headers: {
+        "X-Requested-By": "comerge-cli"
+      }
+    }
+  });
+}
+function toStoredSession(session) {
+  if (!session.access_token || !session.refresh_token || !session.expires_at) {
+    throw new ComergeError("Supabase session is missing required fields.", { exitCode: 1 });
+  }
+  return {
+    access_token: session.access_token,
+    refresh_token: session.refresh_token,
+    expires_at: session.expires_at,
+    token_type: session.token_type ?? void 0,
+    user: session.user ? { id: session.user.id, email: session.user.email ?? null } : void 0
+  };
+}
+function createSupabaseAuthHelpers(config) {
+  const storage = createInMemoryStorage();
+  const supabase = createSupabaseClient(config, storage);
+  return {
+    async startGoogleLogin(params) {
+      const { data, error } = await supabase.auth.signInWithOAuth({
+        provider: "google",
+        options: {
+          redirectTo: params.redirectTo,
+          skipBrowserRedirect: true,
+          queryParams: {
+            access_type: "offline",
+            prompt: "consent"
+          }
+        }
+      });
+      if (error) throw error;
+      if (!data?.url) throw new ComergeError("Supabase did not return an OAuth URL.", { exitCode: 1 });
+      return { url: data.url };
+    },
+    async exchangeCode(params) {
+      const { data, error } = await supabase.auth.exchangeCodeForSession(params.code);
+      if (error) throw error;
+      if (!data?.session) throw new ComergeError("Supabase did not return a session.", { exitCode: 1 });
+      return toStoredSession(data.session);
+    },
+    async refreshWithStoredSession(params) {
+      const { data, error } = await supabase.auth.setSession({
+        access_token: params.session.access_token,
+        refresh_token: params.session.refresh_token
+      });
+      if (error) throw error;
+      if (!data?.session) throw new ComergeError("No session returned after refresh.", { exitCode: 1 });
+      return toStoredSession(data.session);
+    }
+  };
+}
+
+export {
+  storedSessionSchema,
+  createLocalSessionStore,
+  shouldRefreshSoon,
+  createStoredSessionTokenProvider,
+  createSupabaseAuthHelpers
+};

package/dist/chunk-7WUKH3ZD.js

@@ -0,0 +1,221 @@
+import {
+  ComergeError
+} from "./chunk-K57ZFDGC.js";
+
+// src/auth/session.ts
+import { z } from "zod";
+var storedSessionSchema = z.object({
+  access_token: z.string().min(1),
+  refresh_token: z.string().min(1),
+  expires_at: z.number().int().positive(),
+  token_type: z.string().min(1).optional(),
+  user: z.object({
+    id: z.string().min(1),
+    email: z.string().email().optional().nullable()
+  }).optional()
+});
+
+// src/auth/localSessionStore.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+function xdgConfigHome() {
+  const value = process.env.XDG_CONFIG_HOME;
+  if (typeof value === "string" && value.trim()) return value;
+  return path.join(os.homedir(), ".config");
+}
+async function maybeLoadKeytar() {
+  try {
+    const mod = await new Function("return import('keytar')")();
+    const candidates = [mod, mod?.default].filter(Boolean);
+    for (const candidate of candidates) {
+      const value = candidate;
+      if (typeof value.getPassword === "function" && typeof value.setPassword === "function") {
+        return value;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function ensurePathPermissions(filePath) {
+  const dir = path.dirname(filePath);
+  await fs.mkdir(dir, { recursive: true });
+  try {
+    await fs.chmod(dir, 448);
+  } catch {
+  }
+  try {
+    await fs.chmod(filePath, 384);
+  } catch {
+  }
+}
+async function writeJsonAtomic(filePath, value) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  await fs.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  await fs.rename(tmpPath, filePath);
+}
+function createLocalSessionStore(params) {
+  const service = params?.service?.trim() || "comerge-cli";
+  const account = params?.account?.trim() || "default";
+  const filePath = params?.filePath?.trim() || path.join(xdgConfigHome(), "comerge", "session.json");
+  return {
+    async getSession() {
+      const keytar = await maybeLoadKeytar();
+      if (keytar) {
+        const raw2 = await keytar.getPassword(service, account);
+        if (!raw2) return null;
+        try {
+          const parsed = storedSessionSchema.safeParse(JSON.parse(raw2));
+          return parsed.success ? parsed.data : null;
+        } catch {
+          return null;
+        }
+      }
+      const raw = await fs.readFile(filePath, "utf8").catch(() => null);
+      if (!raw) return null;
+      try {
+        const parsed = storedSessionSchema.safeParse(JSON.parse(raw));
+        if (!parsed.success) return null;
+        await ensurePathPermissions(filePath);
+        return parsed.data;
+      } catch {
+        return null;
+      }
+    },
+    async setSession(session) {
+      const parsed = storedSessionSchema.safeParse(session);
+      if (!parsed.success) {
+        throw new Error("Session data is invalid and was not stored.");
+      }
+      const keytar = await maybeLoadKeytar();
+      if (keytar) {
+        await keytar.setPassword(service, account, JSON.stringify(parsed.data));
+        return;
+      }
+      await writeJsonAtomic(filePath, parsed.data);
+      await ensurePathPermissions(filePath);
+    }
+  };
+}
+
+// src/auth/tokenProvider.ts
+function shouldRefreshSoon(session, skewSeconds = 60) {
+  const nowSec = Math.floor(Date.now() / 1e3);
+  return session.expires_at <= nowSec + skewSeconds;
+}
+function createStoredSessionTokenProvider(params) {
+  return async (opts) => {
+    const forceRefresh = Boolean(opts?.forceRefresh);
+    const envToken = process.env.COMERGE_ACCESS_TOKEN;
+    if (typeof envToken === "string" && envToken.trim().length > 0) {
+      return { token: envToken.trim(), session: null, fromEnv: true };
+    }
+    let session = await params.sessionStore.getSession();
+    if (!session) {
+      throw new ComergeError("Not signed in.", {
+        exitCode: 2,
+        hint: "Run `comerge login`, or set COMERGE_ACCESS_TOKEN for CI."
+      });
+    }
+    if (forceRefresh || shouldRefreshSoon(session)) {
+      try {
+        session = await params.refreshStoredSession({ config: params.config, session });
+        await params.sessionStore.setSession(session);
+      } catch (err) {
+        void err;
+      }
+    }
+    return { token: session.access_token, session, fromEnv: false };
+  };
+}
+
+// src/auth/supabase.ts
+import { createClient } from "@supabase/supabase-js";
+function createInMemoryStorage() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    getItem: (k) => map.get(k) ?? null,
+    setItem: (k, v) => {
+      map.set(k, v);
+    },
+    removeItem: (k) => {
+      map.delete(k);
+    }
+  };
+}
+function createSupabaseClient(config, storage) {
+  return createClient(config.supabaseUrl, config.supabaseAnonKey, {
+    auth: {
+      flowType: "pkce",
+      persistSession: false,
+      autoRefreshToken: false,
+      detectSessionInUrl: false,
+      storage
+    },
+    global: {
+      headers: {
+        "X-Requested-By": "comerge-cli"
+      }
+    }
+  });
+}
+function toStoredSession(session) {
+  if (!session.access_token || !session.refresh_token || !session.expires_at) {
+    throw new ComergeError("Supabase session is missing required fields.", { exitCode: 1 });
+  }
+  return {
+    access_token: session.access_token,
+    refresh_token: session.refresh_token,
+    expires_at: session.expires_at,
+    token_type: session.token_type ?? void 0,
+    user: session.user ? { id: session.user.id, email: session.user.email ?? null } : void 0
+  };
+}
+function createSupabaseAuthHelpers(config) {
+  const storage = createInMemoryStorage();
+  const supabase = createSupabaseClient(config, storage);
+  return {
+    async startGoogleLogin(params) {
+      const { data, error } = await supabase.auth.signInWithOAuth({
+        provider: "google",
+        options: {
+          redirectTo: params.redirectTo,
+          skipBrowserRedirect: true,
+          queryParams: {
+            access_type: "offline",
+            prompt: "consent"
+          }
+        }
+      });
+      if (error) throw error;
+      if (!data?.url) throw new ComergeError("Supabase did not return an OAuth URL.", { exitCode: 1 });
+      return { url: data.url };
+    },
+    async exchangeCode(params) {
+      const { data, error } = await supabase.auth.exchangeCodeForSession(params.code);
+      if (error) throw error;
+      if (!data?.session) throw new ComergeError("Supabase did not return a session.", { exitCode: 1 });
+      return toStoredSession(data.session);
+    },
+    async refreshWithStoredSession(params) {
+      const { data, error } = await supabase.auth.setSession({
+        access_token: params.session.access_token,
+        refresh_token: params.session.refresh_token
+      });
+      if (error) throw error;
+      if (!data?.session) throw new ComergeError("No session returned after refresh.", { exitCode: 1 });
+      return toStoredSession(data.session);
+    }
+  };
+}
+
+export {
+  storedSessionSchema,
+  createLocalSessionStore,
+  shouldRefreshSoon,
+  createStoredSessionTokenProvider,
+  createSupabaseAuthHelpers
+};

package/dist/chunk-AE2HPMUZ.js

@@ -0,0 +1,80 @@
+import {
+  ComergeError
+} from "./chunk-K57ZFDGC.js";
+
+// src/infrastructure/binding/collabBindingStore.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+
+// src/shared/fs.ts
+import fs from "fs/promises";
+import path from "path";
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findAvailableDirPath(preferredDir) {
+  if (!await pathExists(preferredDir)) return preferredDir;
+  const parent = path.dirname(preferredDir);
+  const base = path.basename(preferredDir);
+  for (let i = 2; i <= 1e3; i++) {
+    const candidate = path.join(parent, `${base}-${i}`);
+    if (!await pathExists(candidate)) return candidate;
+  }
+  throw new ComergeError("No available output directory name.", {
+    exitCode: 2,
+    hint: `Tried ${base}-2 through ${base}-1000 under ${parent}.`
+  });
+}
+async function writeJsonAtomic(filePath, value) {
+  const dir = path.dirname(filePath);
+  await fs.mkdir(dir, { recursive: true });
+  const tmp = `${filePath}.tmp-${Date.now()}`;
+  await fs.writeFile(tmp, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  await fs.rename(tmp, filePath);
+}
+
+// src/infrastructure/binding/collabBindingStore.ts
+function getCollabBindingPath(repoRoot) {
+  return path2.join(repoRoot, ".comerge", "config.json");
+}
+async function readCollabBinding(repoRoot) {
+  try {
+    const raw = await fs2.readFile(getCollabBindingPath(repoRoot), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed?.schemaVersion !== 1) return null;
+    if (!parsed.projectId || !parsed.currentAppId || !parsed.upstreamAppId) return null;
+    return {
+      schemaVersion: 1,
+      projectId: parsed.projectId,
+      currentAppId: parsed.currentAppId,
+      upstreamAppId: parsed.upstreamAppId,
+      threadId: parsed.threadId ?? null,
+      repoFingerprint: parsed.repoFingerprint ?? null,
+      remoteUrl: parsed.remoteUrl ?? null,
+      defaultBranch: parsed.defaultBranch ?? null
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeCollabBinding(repoRoot, binding) {
+  const filePath = getCollabBindingPath(repoRoot);
+  await writeJsonAtomic(filePath, {
+    schemaVersion: 1,
+    ...binding
+  });
+  return filePath;
+}
+
+export {
+  findAvailableDirPath,
+  getCollabBindingPath,
+  readCollabBinding,
+  writeCollabBinding
+};