@remixhq/core 0.1.2

package/dist/chunk-EVWDYCBL.js

@@ -0,0 +1,223 @@
+import {
+  RemixError
+} from "./chunk-YZ34ICNN.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() || "remix-cli";
+  const account = params?.account?.trim() || "default";
+  const filePath = params?.filePath?.trim() || path.join(xdgConfigHome(), "remix", "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 RemixError("Not signed in.", {
+        exitCode: 2,
+        hint: "Run `remix 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 RemixError("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 RemixError("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 RemixError("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 RemixError("No session returned after refresh.", { exitCode: 1 });
+      return toStoredSession(data.session);
+    }
+  };
+}
+
+export {
+  storedSessionSchema,
+  createLocalSessionStore,
+  shouldRefreshSoon,
+  createStoredSessionTokenProvider,
+  createSupabaseAuthHelpers
+};

package/dist/chunk-FAZUMWBS.js

@@ -0,0 +1,93 @@
+import {
+  RemixError
+} from "./chunk-YZ34ICNN.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 reserveDirectory(targetDir) {
+  try {
+    await fs.mkdir(targetDir);
+    return targetDir;
+  } catch (error) {
+    if (error?.code === "EEXIST") {
+      throw new RemixError("Output directory already exists.", {
+        exitCode: 2,
+        hint: `Choose an empty destination path: ${targetDir}`
+      });
+    }
+    throw error;
+  }
+}
+async function reserveAvailableDirPath(preferredDir) {
+  const parent = path.dirname(preferredDir);
+  const base = path.basename(preferredDir);
+  for (let i = 1; i <= 1e3; i += 1) {
+    const candidate = i === 1 ? preferredDir : path.join(parent, `${base}-${i}`);
+    try {
+      await fs.mkdir(candidate);
+      return candidate;
+    } catch (error) {
+      if (error?.code === "EEXIST") continue;
+      throw error;
+    }
+  }
+  throw new RemixError("No available output directory name.", {
+    exitCode: 2,
+    hint: `Tried ${base} 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, ".remix", "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,
+      preferredBranch: parsed.preferredBranch ?? parsed.defaultBranch ?? null
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeCollabBinding(repoRoot, binding) {
+  const filePath = getCollabBindingPath(repoRoot);
+  await writeJsonAtomic(filePath, {
+    schemaVersion: 1,
+    ...binding
+  });
+  return filePath;
+}
+
+export {
+  reserveDirectory,
+  reserveAvailableDirPath,
+  getCollabBindingPath,
+  readCollabBinding,
+  writeCollabBinding
+};

package/dist/chunk-GC2MOT3U.js

@@ -0,0 +1,12 @@
+// src/errors/errorCodes.ts
+var REMIX_ERROR_CODES = {
+  REPO_LOCK_HELD: "REPO_LOCK_HELD",
+  REPO_LOCK_TIMEOUT: "REPO_LOCK_TIMEOUT",
+  REPO_LOCK_STALE_RECOVERED: "REPO_LOCK_STALE_RECOVERED",
+  REPO_STATE_CHANGED_DURING_OPERATION: "REPO_STATE_CHANGED_DURING_OPERATION",
+  PREFERRED_BRANCH_MISMATCH: "PREFERRED_BRANCH_MISMATCH"
+};
+
+export {
+  REMIX_ERROR_CODES
+};

package/dist/chunk-GFOBGYW4.js

@@ -0,0 +1,252 @@
+import {
+  ComergeError
+} from "./chunk-K57ZFDGC.js";
+
+// src/api/client.ts
+async function readJsonSafe(res) {
+  const ct = res.headers.get("content-type") ?? "";
+  if (!ct.toLowerCase().includes("application/json")) return null;
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+function createApiClient(config, opts) {
+  const apiKey = (opts?.apiKey ?? "").trim();
+  const tokenProvider = opts?.tokenProvider;
+  const CLIENT_KEY_HEADER = "x-comerge-api-key";
+  async function request(path, init) {
+    if (!tokenProvider) {
+      throw new ComergeError("API client is missing a token provider.", {
+        exitCode: 1,
+        hint: "Configure auth before creating the Comerge API client."
+      });
+    }
+    const auth = await tokenProvider();
+    const url = new URL(path, config.apiUrl).toString();
+    const doFetch = async (bearer) => fetch(url, {
+      ...init,
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        ...init?.headers ?? {},
+        Authorization: `Bearer ${bearer}`,
+        ...apiKey ? { [CLIENT_KEY_HEADER]: apiKey } : {}
+      }
+    });
+    let res = await doFetch(auth.token);
+    if (res.status === 401 && !auth.fromEnv && auth.session?.refresh_token) {
+      const refreshed = await tokenProvider({ forceRefresh: true });
+      res = await doFetch(refreshed.token);
+    }
+    if (!res.ok) {
+      const body = await readJsonSafe(res);
+      const msg = (body && typeof body === "object" && body && "message" in body && typeof body.message === "string" ? body.message : null) ?? `Request failed (status ${res.status})`;
+      throw new ComergeError(msg, { exitCode: 1, hint: body ? JSON.stringify(body, null, 2) : null });
+    }
+    const json = await readJsonSafe(res);
+    return json ?? null;
+  }
+  async function requestBinary(path, init) {
+    if (!tokenProvider) {
+      throw new ComergeError("API client is missing a token provider.", {
+        exitCode: 1,
+        hint: "Configure auth before creating the Comerge API client."
+      });
+    }
+    const auth = await tokenProvider();
+    const url = new URL(path, config.apiUrl).toString();
+    const doFetch = async (bearer) => fetch(url, {
+      ...init,
+      headers: {
+        Accept: "*/*",
+        ...init?.headers ?? {},
+        Authorization: `Bearer ${bearer}`,
+        ...apiKey ? { [CLIENT_KEY_HEADER]: apiKey } : {}
+      }
+    });
+    let res = await doFetch(auth.token);
+    if (res.status === 401 && !auth.fromEnv && auth.session?.refresh_token) {
+      const refreshed = await tokenProvider({ forceRefresh: true });
+      res = await doFetch(refreshed.token);
+    }
+    if (!res.ok) {
+      const body = await readJsonSafe(res);
+      const msg = (body && typeof body === "object" && body && "message" in body && typeof body.message === "string" ? body.message : null) ?? `Request failed (status ${res.status})`;
+      throw new ComergeError(msg, { exitCode: 1, hint: body ? JSON.stringify(body, null, 2) : null });
+    }
+    const contentDisposition = res.headers.get("content-disposition") ?? "";
+    const fileNameMatch = contentDisposition.match(/filename=\"([^\"]+)\"/i);
+    return {
+      data: Buffer.from(await res.arrayBuffer()),
+      fileName: fileNameMatch?.[1] ?? null,
+      contentType: res.headers.get("content-type")
+    };
+  }
+  return {
+    getMe: () => request("/v1/me", { method: "GET" }),
+    listOrganizations: () => request("/v1/organizations", { method: "GET" }),
+    listProjects: (params) => {
+      const qs = new URLSearchParams();
+      if (params?.organizationId) qs.set("organizationId", params.organizationId);
+      if (params?.clientAppId) qs.set("clientAppId", params.clientAppId);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/projects${suffix}`, { method: "GET" });
+    },
+    resolveProjectBinding: (params) => {
+      const qs = new URLSearchParams();
+      if (params.repoFingerprint) qs.set("repoFingerprint", params.repoFingerprint);
+      if (params.remoteUrl) qs.set("remoteUrl", params.remoteUrl);
+      return request(`/v1/projects/bindings/resolve?${qs.toString()}`, { method: "GET" });
+    },
+    autoEnableDeveloper: () => request("/v1/developer/auto-enable", { method: "POST" }),
+    listClientApps: (params) => {
+      const qs = params?.orgId ? `?orgId=${encodeURIComponent(params.orgId)}` : "";
+      return request(`/v1/developer/client-apps${qs}`, { method: "GET" });
+    },
+    createClientApp: (payload) => request("/v1/developer/client-apps", { method: "POST", body: JSON.stringify(payload) }),
+    createClientAppKey: (clientAppId, payload) => request(`/v1/developer/client-apps/${encodeURIComponent(clientAppId)}/keys`, {
+      method: "POST",
+      body: JSON.stringify(payload ?? {})
+    }),
+    listApps: (params) => {
+      const qs = new URLSearchParams();
+      if (params?.projectId) qs.set("projectId", params.projectId);
+      if (params?.organizationId) qs.set("organizationId", params.organizationId);
+      if (params?.forked) qs.set("forked", params.forked);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps${suffix}`, { method: "GET" });
+    },
+    getApp: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}`, { method: "GET" }),
+    getMergeRequest: (mrId) => request(`/v1/merge-requests/${encodeURIComponent(mrId)}`, { method: "GET" }),
+    presignImportUpload: (payload) => request("/v1/apps/import/upload/presign", { method: "POST", body: JSON.stringify(payload) }),
+    importFromUpload: (payload) => request("/v1/apps/import/upload", { method: "POST", body: JSON.stringify(payload) }),
+    presignImportUploadFirstParty: (payload) => request("/v1/apps/import/upload/presign/first-party", { method: "POST", body: JSON.stringify(payload) }),
+    importFromUploadFirstParty: (payload) => request("/v1/apps/import/upload/first-party", { method: "POST", body: JSON.stringify(payload) }),
+    importFromGithubFirstParty: (payload) => request("/v1/apps/import/github/first-party", { method: "POST", body: JSON.stringify(payload) }),
+    forkApp: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/fork`, { method: "POST", body: JSON.stringify(payload ?? {}) }),
+    downloadAppBundle: (appId) => requestBinary(`/v1/apps/${encodeURIComponent(appId)}/download.bundle`, { method: "GET" }),
+    createChangeStep: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    createCollabTurn: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    listCollabTurns: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (params?.limit !== void 0) qs.set("limit", String(params.limit));
+      if (params?.offset !== void 0) qs.set("offset", String(params.offset));
+      if (params?.changeStepId) qs.set("changeStepId", params.changeStepId);
+      if (params?.threadId) qs.set("threadId", params.threadId);
+      if (params?.createdAfter) qs.set("createdAfter", params.createdAfter);
+      if (params?.createdBefore) qs.set("createdBefore", params.createdBefore);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns${suffix}`, { method: "GET" });
+    },
+    getCollabTurn: (appId, collabTurnId) => request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns/${encodeURIComponent(collabTurnId)}`, {
+      method: "GET"
+    }),
+    getAgentMemorySummary: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/agent-memory/summary`, { method: "GET" }),
+    listAgentMemoryTimeline: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (params?.limit !== void 0) qs.set("limit", String(params.limit));
+      if (params?.offset !== void 0) qs.set("offset", String(params.offset));
+      if (params?.createdAfter) qs.set("createdAfter", params.createdAfter);
+      if (params?.createdBefore) qs.set("createdBefore", params.createdBefore);
+      if (params?.kinds?.length) {
+        for (const kind of params.kinds) qs.append("kinds", kind);
+      }
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/agent-memory/timeline${suffix}`, { method: "GET" });
+    },
+    searchAgentMemory: (appId, params) => {
+      const qs = new URLSearchParams();
+      qs.set("q", params.q);
+      if (params.limit !== void 0) qs.set("limit", String(params.limit));
+      if (params.offset !== void 0) qs.set("offset", String(params.offset));
+      if (params.createdAfter) qs.set("createdAfter", params.createdAfter);
+      if (params.createdBefore) qs.set("createdBefore", params.createdBefore);
+      if (params.kinds?.length) {
+        for (const kind of params.kinds) qs.append("kinds", kind);
+      }
+      return request(`/v1/apps/${encodeURIComponent(appId)}/agent-memory/search?${qs.toString()}`, { method: "GET" });
+    },
+    getChangeStep: (appId, changeStepId) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps/${encodeURIComponent(changeStepId)}`, { method: "GET" }),
+    getChangeStepDiff: (appId, changeStepId) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps/${encodeURIComponent(changeStepId)}/diff`, {
+      method: "GET"
+    }),
+    startChangeStepReplay: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps/replays`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    getChangeStepReplay: (appId, replayId) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps/replays/${encodeURIComponent(replayId)}`, {
+      method: "GET"
+    }),
+    getChangeStepReplayDiff: (appId, replayId) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps/replays/${encodeURIComponent(replayId)}/diff`, {
+      method: "GET"
+    }),
+    listMergeRequests: (params) => {
+      const qs = new URLSearchParams();
+      if (params?.sourceAppId) qs.set("sourceAppId", params.sourceAppId);
+      if (params?.targetAppId) qs.set("targetAppId", params.targetAppId);
+      if (Array.isArray(params?.status)) {
+        for (const status of params.status) qs.append("status", status);
+      } else if (typeof params?.status === "string") {
+        qs.set("status", params.status);
+      }
+      if (params?.kind) qs.set("kind", params.kind);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/merge-requests${suffix}`, { method: "GET" });
+    },
+    openMergeRequest: (sourceAppId) => request("/v1/merge-requests", { method: "POST", body: JSON.stringify({ sourceAppId }) }),
+    getMergeRequestReview: (mrId) => request(`/v1/merge-requests/${encodeURIComponent(mrId)}/review`, { method: "GET" }),
+    updateMergeRequest: (mrId, payload) => request(`/v1/merge-requests/${encodeURIComponent(mrId)}`, { method: "PATCH", body: JSON.stringify(payload) }),
+    createProjectInvite: (projectId, payload) => request(`/v1/projects/${encodeURIComponent(projectId)}/invitations`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    syncUpstreamApp: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/sync-upstream`, {
+      method: "POST",
+      body: JSON.stringify({})
+    }),
+    preflightAppReconcile: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/reconcile/preflight`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    startAppReconcile: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/reconcile/start`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    getAppReconcile: (appId, reconcileId) => request(`/v1/apps/${encodeURIComponent(appId)}/reconcile/${encodeURIComponent(reconcileId)}`, { method: "GET" }),
+    downloadAppReconcileBundle: (appId, reconcileId) => requestBinary(`/v1/apps/${encodeURIComponent(appId)}/reconcile/${encodeURIComponent(reconcileId)}/download.bundle`, {
+      method: "GET"
+    }),
+    syncLocalApp: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/sync-local`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    initiateBundle: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/bundles`, { method: "POST", body: JSON.stringify(payload) }),
+    getBundle: (appId, bundleId) => request(`/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}`, { method: "GET" }),
+    getBundleDownloadUrl: (appId, bundleId, options) => request(
+      `/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}/download?redirect=${options?.redirect ?? false}`,
+      { method: "GET" }
+    ),
+    getBundleAssetsDownloadUrl: (appId, bundleId, options) => {
+      const qs = new URLSearchParams({
+        redirect: String(options?.redirect ?? false),
+        kind: options?.kind ?? "metro-assets"
+      });
+      return request(
+        `/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}/assets/download?${qs.toString()}`,
+        { method: "GET" }
+      );
+    }
+  };
+}
+
+export {
+  createApiClient
+};

package/dist/chunk-INDDXWAH.js

@@ -0,0 +1,92 @@
+import {
+  ComergeError
+} from "./chunk-ZBMOGUSJ.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 reserveDirectory(targetDir) {
+  try {
+    await fs.mkdir(targetDir);
+    return targetDir;
+  } catch (error) {
+    if (error?.code === "EEXIST") {
+      throw new ComergeError("Output directory already exists.", {
+        exitCode: 2,
+        hint: `Choose an empty destination path: ${targetDir}`
+      });
+    }
+    throw error;
+  }
+}
+async function reserveAvailableDirPath(preferredDir) {
+  const parent = path.dirname(preferredDir);
+  const base = path.basename(preferredDir);
+  for (let i = 1; i <= 1e3; i += 1) {
+    const candidate = i === 1 ? preferredDir : path.join(parent, `${base}-${i}`);
+    try {
+      await fs.mkdir(candidate);
+      return candidate;
+    } catch (error) {
+      if (error?.code === "EEXIST") continue;
+      throw error;
+    }
+  }
+  throw new ComergeError("No available output directory name.", {
+    exitCode: 2,
+    hint: `Tried ${base} 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 {
+  reserveDirectory,
+  reserveAvailableDirPath,
+  getCollabBindingPath,
+  readCollabBinding,
+  writeCollabBinding
+};

package/dist/chunk-K57ZFDGC.js

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