@remixhq/core 0.1.2

package/dist/chunk-VM3CGCNX.js

@@ -0,0 +1,46 @@
+import {
+  RemixError
+} from "./chunk-YZ34ICNN.js";
+
+// src/config/model.ts
+import { z } from "zod";
+var DEFAULT_API_URL = "https://api.remix.one";
+var DEFAULT_SUPABASE_URL = "https://xtfxwbckjpfmqubnsusu.supabase.co";
+var DEFAULT_SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Inh0Znh3YmNranBmbXF1Ym5zdXN1Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjA2MDEyMzAsImV4cCI6MjA3NjE3NzIzMH0.dzWGAWrK4CvrmHVHzf8w7JlUZohdap0ZPnLZnABMV8s";
+function isValidUrl(value) {
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var urlSchema = z.string().min(1).transform((s) => s.trim()).refine((s) => isValidUrl(s), "Invalid URL.").transform((s) => s.replace(/\/+$/, ""));
+var configSchema = z.object({
+  apiUrl: urlSchema,
+  supabaseUrl: urlSchema,
+  supabaseAnonKey: z.string().min(1)
+});
+var cachedConfig = null;
+async function resolveConfig(_opts) {
+  if (cachedConfig) return cachedConfig;
+  const cfgRaw = {
+    apiUrl: DEFAULT_API_URL,
+    supabaseUrl: DEFAULT_SUPABASE_URL,
+    supabaseAnonKey: DEFAULT_SUPABASE_ANON_KEY
+  };
+  const parsedCfg = configSchema.safeParse(cfgRaw);
+  if (!parsedCfg.success) {
+    throw new RemixError("Invalid core configuration.", {
+      exitCode: 1,
+      hint: parsedCfg.error.issues.map((i) => `${i.path.join(".") || "config"}: ${i.message}`).join("; ")
+    });
+  }
+  cachedConfig = parsedCfg.data;
+  return parsedCfg.data;
+}
+
+export {
+  configSchema,
+  resolveConfig
+};

package/dist/chunk-XOQIADCH.js

@@ -0,0 +1,223 @@
+import {
+  ComergeError
+} from "./chunk-ZBMOGUSJ.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-YZ34ICNN.js

@@ -0,0 +1,17 @@
+// src/errors/cliError.ts
+var RemixError = class extends Error {
+  code;
+  exitCode;
+  hint;
+  constructor(message, opts) {
+    super(message);
+    this.name = "RemixError";
+    this.code = opts?.code ?? null;
+    this.exitCode = opts?.exitCode ?? 1;
+    this.hint = opts?.hint ?? null;
+  }
+};
+
+export {
+  RemixError
+};

package/dist/chunk-ZBMOGUSJ.js

@@ -0,0 +1,17 @@
+// src/errors/cliError.ts
+var ComergeError = class extends Error {
+  code;
+  exitCode;
+  hint;
+  constructor(message, opts) {
+    super(message);
+    this.name = "ComergeError";
+    this.code = opts?.code ?? null;
+    this.exitCode = opts?.exitCode ?? 1;
+    this.hint = opts?.hint ?? null;
+  }
+};
+
+export {
+  ComergeError
+};