@remixhq/core 0.1.13 → 0.1.14

package/dist/api.d.ts

@@ -1,7 +1,76 @@
 import { CoreConfig } from './config.js';
 import { T as TokenProvider } from './tokenProvider-BWTusyj4.js';
+import { E as TurnUsage } from './contracts-NbV3P_Rl.js';
 import 'zod';
 
+type HistoryImportProvider = "claude_code" | "cursor";
+type HistoryImportCaptureSource = "claude_local_v1" | "cursor_local_v1" | "cursor_local_v1_drift";
+type HistoryImportRecordMetadata = {
+    importBatchId: string;
+    importerVersion: string;
+    scannerSchemaFingerprint?: string;
+    rawCwd?: string;
+    driftDetected?: boolean;
+};
+type HistoryImportWorkspaceMetadata = {
+    turnUsage: TurnUsage;
+    branch?: string;
+} & Record<string, unknown>;
+type HistoricalTurnRecord = {
+    provider: HistoryImportProvider;
+    providerSessionId: string | null;
+    providerTurnId: string;
+    repoFingerprint: string;
+    captureSource: HistoryImportCaptureSource;
+    occurredAt: string;
+    promptText: string | null;
+    assistantText?: string | null;
+    workspaceMetadata: HistoryImportWorkspaceMetadata;
+    metadata: HistoryImportRecordMetadata;
+    dedupKey: string;
+};
+type ImportHistoryRequest = {
+    records: HistoricalTurnRecord[];
+};
+type ImportHistoryRecordOutcome = {
+    ok: true;
+    outcome: "inserted";
+    historicalRepoTurnId: string;
+} | {
+    ok: true;
+    outcome: "skipped_duplicate";
+} | {
+    ok: false;
+    outcome: "validation_failed";
+    reason: string;
+} | {
+    ok: false;
+    outcome: "dedup_key_mismatch";
+    expected: string;
+} | {
+    ok: false;
+    outcome: "insert_failed";
+    reason: string;
+};
+type ImportHistoryResponse = {
+    importBatchId: string;
+    processed: number;
+    inserted: number;
+    skipped: number;
+    failed: number;
+    perRepo: Array<{
+        repoFingerprint: string;
+        inserted: number;
+        skipped: number;
+        failed: number;
+    }>;
+    failures: Array<{
+        dedupKey: string;
+        outcome: Exclude<ImportHistoryRecordOutcome["outcome"], "inserted" | "skipped_duplicate">;
+        reason: string;
+    }>;
+};
+
 type Json = Record<string, unknown> | unknown[] | string | number | boolean | null;
 type MergeRequestStatus = "open" | "approved" | "rejected" | "merged" | "closed";
 type MergeRequest = {
@@ -413,6 +482,7 @@ type ApiClient = {
         defaultBranch?: string;
         repoFingerprint?: string;
         headCommitHash?: string;
+        forceNew?: boolean;
     }): Promise<Json>;
     importFromGithubFirstParty(payload: {
         repoFullName: string;
@@ -499,6 +569,10 @@ type ApiClient = {
         workspaceMetadata?: Record<string, unknown>;
         idempotencyKey?: string;
     }): Promise<Json>;
+    attachCollabTurnUsage(appId: string, payload: {
+        prompt: string;
+        workspaceMetadata: Record<string, unknown>;
+    }): Promise<Json>;
     listCollabTurns(appId: string, params?: {
         limit?: number;
         offset?: number;
@@ -660,10 +734,11 @@ type ApiClient = {
         createdBefore?: string;
     }): Promise<Json>;
     getSandboxStatus(appId: string): Promise<Json>;
+    importHistory(payload: ImportHistoryRequest): Promise<ImportHistoryResponse>;
 };
 declare function createApiClient(config: CoreConfig, opts?: {
     apiKey?: string | null;
     tokenProvider?: TokenProvider;
 }): ApiClient;
 
-export { type AgentMemoryItem, type AgentMemoryKind, type AgentMemorySearchItem, type AgentMemorySearchResponse, type AgentMemorySummary, type AgentMemoryTimelineResponse, type ApiClient, type AppContext, type AppContextAccessPath, type AppReconcileResponse, type Bundle, type BundlePlatform, type BundleStatus, type ChangeStepDiffResponse, type InitiateBundleRequest, type InvitationRecord, type MergeRequest, type MergeRequestReview, type MergeRequestStatus, type ReconcilePreflightResponse, type SyncLocalResponse, type SyncUpstreamResponse, createApiClient };
+export { type AgentMemoryItem, type AgentMemoryKind, type AgentMemorySearchItem, type AgentMemorySearchResponse, type AgentMemorySummary, type AgentMemoryTimelineResponse, type ApiClient, type AppContext, type AppContextAccessPath, type AppReconcileResponse, type Bundle, type BundlePlatform, type BundleStatus, type ChangeStepDiffResponse, type HistoricalTurnRecord, type HistoryImportCaptureSource, type HistoryImportProvider, type HistoryImportRecordMetadata, type HistoryImportWorkspaceMetadata, type ImportHistoryRecordOutcome, type ImportHistoryRequest, type ImportHistoryResponse, type InitiateBundleRequest, type InvitationRecord, type MergeRequest, type MergeRequestReview, type MergeRequestStatus, type ReconcilePreflightResponse, type SyncLocalResponse, type SyncUpstreamResponse, createApiClient };

package/dist/api.js

@@ -1,6 +1,6 @@
 import {
   createApiClient
-} from "./chunk-R7FVSCQW.js";
+} from "./chunk-US5SM7ZC.js";
 import "./chunk-YZ34ICNN.js";
 export {
   createApiClient

package/dist/auth.js

@@ -4,7 +4,7 @@ import {
   createSupabaseAuthHelpers,
   shouldRefreshSoon,
   storedSessionSchema
-} from "./chunk-EVWDYCBL.js";
+} from "./chunk-P6JHXOV4.js";
 import "./chunk-YZ34ICNN.js";
 export {
   createLocalSessionStore,

package/dist/binding-WiIRI2fl.d.ts

@@ -0,0 +1,43 @@
+type BranchBindingMode = "legacy" | "lane" | "explicit_root";
+type BranchBinding = {
+    projectId: string | null;
+    currentAppId: string;
+    upstreamAppId: string;
+    threadId: string | null;
+    laneId: string | null;
+    bindingMode: BranchBindingMode;
+};
+type CollabBinding = {
+    schemaVersion: 3;
+    projectId: string | null;
+    currentAppId: string;
+    upstreamAppId: string;
+    threadId: string | null;
+    repoFingerprint: string | null;
+    remoteUrl: string | null;
+    defaultBranch: string | null;
+    laneId: string | null;
+    branchName: string | null;
+    bindingMode: BranchBindingMode;
+};
+declare function getCollabBindingPath(repoRoot: string): string;
+type CollabBindingState = {
+    schemaVersion: 1 | 2 | 3;
+    projectId: string | null;
+    repoFingerprint: string | null;
+    remoteUrl: string | null;
+    defaultBranch: string | null;
+    currentBranch: string | null;
+    binding: CollabBinding | null;
+    branchBindings: Record<string, BranchBinding>;
+    explicitRootBinding: CollabBinding | null;
+};
+declare function readCollabBindingState(repoRoot: string, options?: {
+    persist?: boolean;
+}): Promise<CollabBindingState | null>;
+declare function readCollabBinding(repoRoot: string): Promise<CollabBinding | null>;
+declare function writeCollabBinding(repoRoot: string, binding: Omit<CollabBinding, "schemaVersion" | "branchName"> & {
+    branchName?: string | null;
+}): Promise<string>;
+
+export { type BranchBindingMode as B, type CollabBinding as C, type CollabBindingState as a, readCollabBindingState as b, getCollabBindingPath as g, readCollabBinding as r, writeCollabBinding as w };

package/dist/binding.d.ts

@@ -1,21 +1 @@
-type BranchBindingMode = "legacy" | "lane" | "explicit_root";
-type CollabBinding = {
-    schemaVersion: 3;
-    projectId: string | null;
-    currentAppId: string;
-    upstreamAppId: string;
-    threadId: string | null;
-    repoFingerprint: string | null;
-    remoteUrl: string | null;
-    defaultBranch: string | null;
-    laneId: string | null;
-    branchName: string | null;
-    bindingMode: BranchBindingMode;
-};
-declare function getCollabBindingPath(repoRoot: string): string;
-declare function readCollabBinding(repoRoot: string): Promise<CollabBinding | null>;
-declare function writeCollabBinding(repoRoot: string, binding: Omit<CollabBinding, "schemaVersion" | "branchName"> & {
-    branchName?: string | null;
-}): Promise<string>;
-
-export { type CollabBinding, getCollabBindingPath, readCollabBinding, writeCollabBinding };
+export { C as CollabBinding, a as CollabBindingState, g as getCollabBindingPath, r as readCollabBinding, b as readCollabBindingState, w as writeCollabBinding } from './binding-WiIRI2fl.js';

package/dist/binding.js

@@ -1,6 +1,7 @@
 import {
   getCollabBindingPath,
   readCollabBinding,
+  readCollabBindingState,
   writeCollabBinding
 } from "./chunk-YCFLOHJV.js";
 import "./chunk-WT6VRLXU.js";
@@ -9,5 +10,6 @@ import "./chunk-YZ34ICNN.js";
 export {
   getCollabBindingPath,
   readCollabBinding,
+  readCollabBindingState,
   writeCollabBinding
 };

package/dist/chunk-P6JHXOV4.js

@@ -0,0 +1,236 @@
+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");
+  async function readKeytar() {
+    const keytar = await maybeLoadKeytar();
+    if (!keytar) return null;
+    const raw = await keytar.getPassword(service, account).catch(() => null);
+    if (!raw) return null;
+    try {
+      const parsed = storedSessionSchema.safeParse(JSON.parse(raw));
+      return parsed.success ? parsed.data : null;
+    } catch {
+      return null;
+    }
+  }
+  async function readFile() {
+    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;
+    }
+  }
+  function pickFreshest(a, b) {
+    if (!a) return b;
+    if (!b) return a;
+    return a.expires_at >= b.expires_at ? a : b;
+  }
+  return {
+    async getSession() {
+      const [k, f] = await Promise.all([readKeytar(), readFile()]);
+      return pickFreshest(k, f);
+    },
+    async setSession(session) {
+      const parsed = storedSessionSchema.safeParse(session);
+      if (!parsed.success) {
+        throw new Error("Session data is invalid and was not stored.");
+      }
+      await writeSessionFileFallback(filePath, parsed.data);
+      const keytar = await maybeLoadKeytar();
+      if (keytar) {
+        try {
+          await keytar.setPassword(service, account, JSON.stringify(parsed.data));
+        } catch {
+        }
+      }
+    }
+  };
+}
+
+// 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
+};