@tracemarketplace/cli 0.0.13 → 0.0.17

package/src/config.ts

@@ -1,19 +1,49 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
+import { DEFAULT_PROFILE } from "./constants.js";
 
-export interface Config {
+export interface StoredProfileConfig {
   apiKey: string;
   serverUrl: string;
   email: string;
 }
 
-// Tracks which chunks of each session have been submitted.
-// Key: "<source_tool>:<source_session_id>", value: highest chunk_index submitted.
+export interface Config extends StoredProfileConfig {
+  profile: string;
+}
+
+export interface ConfigStore {
+  defaultProfile: string;
+  profiles: Record<string, StoredProfileConfig>;
+}
+
+export type TrackedSessionTool = "claude_code" | "codex_cli" | "cursor";
+
+export interface SessionUploadState {
+  sourceTool: TrackedSessionTool;
+  sourceSessionId: string;
+  locator: string;
+  nextChunkIndex: number;
+  openChunkStartTurn: number;
+  lastSeenTurnCount: number;
+  lastActivityAt: string | null;
+  lastFlushedTurnId: string | null;
+  // Async confirmation tracking
+  confirmedChunkIndex: number;         // all chunks below this index are confirmed in DB
+  confirmedOpenChunkStartTurn: number; // openChunkStartTurn to restore if re-submitting
+  unconfirmedSince: string | null;     // ISO timestamp when chunks first went unconfirmed
+}
+
 export interface SubmitState {
+  version: 2;
   chunks: Record<string, number>;
+  sessions: Record<string, SessionUploadState>;
 }
 
+type JsonRecord = Record<string, unknown>;
+const EMPTY_SUBMIT_STATE: SubmitState = { version: 2, chunks: {}, sessions: {} };
+
 export function getConfigDir(): string {
   return join(homedir(), ".config", "tracemarketplace");
 }
@@ -22,40 +52,230 @@ export function getConfigPath(): string {
   return join(getConfigDir(), "config.json");
 }
 
-export function getStatePath(): string {
-  return join(getConfigDir(), "state.json");
+export function getStatePath(profile?: string): string {
+  return join(getConfigDir(), `state${profileSuffix(profile)}.json`);
 }
 
-export function loadConfig(): Config | null {
-  const p = getConfigPath();
-  if (!existsSync(p)) return null;
+export function getAutoSubmitLogPath(profile?: string): string {
+  return join(getConfigDir(), `auto-submit${profileSuffix(profile)}.log`);
+}
+
+export function getDaemonStatePath(profile?: string): string {
+  return join(getConfigDir(), `daemon-state${profileSuffix(profile)}.json`);
+}
+
+export function getDaemonPidPath(profile?: string): string {
+  return join(getConfigDir(), `daemon${profileSuffix(profile)}.pid`);
+}
+
+export function resolveProfile(profile?: string): string {
+  if (profile) return normalizeProfile(profile);
+  if (process.env.TRACEMP_PROFILE) return normalizeProfile(process.env.TRACEMP_PROFILE);
+  return normalizeProfile(loadConfigStore().defaultProfile);
+}
+
+export function loadConfigStore(): ConfigStore {
+  const raw = readConfigFile();
+  if (isStoredProfileConfig(raw)) {
+    return {
+      defaultProfile: DEFAULT_PROFILE,
+      profiles: { [DEFAULT_PROFILE]: normalizeStoredProfileConfig(raw) },
+    };
+  }
+
+  if (!isRecord(raw)) {
+    return {
+      defaultProfile: DEFAULT_PROFILE,
+      profiles: {},
+    };
+  }
+
+  const profiles = normalizeProfiles(raw.profiles);
+  const requestedDefault = normalizeProfile(
+    typeof raw.defaultProfile === "string" ? raw.defaultProfile : DEFAULT_PROFILE
+  );
+
+  return {
+    defaultProfile: profiles[requestedDefault]
+      ? requestedDefault
+      : profiles[DEFAULT_PROFILE]
+        ? DEFAULT_PROFILE
+        : requestedDefault,
+    profiles,
+  };
+}
+
+export function loadConfig(profile?: string): Config | null {
+  const store = loadConfigStore();
+  const resolvedProfile = resolveProfileFromStore(store, profile);
+  const selected = store.profiles[resolvedProfile];
+  if (!selected) return null;
+  return { profile: resolvedProfile, ...selected };
+}
+
+export function saveConfig(
+  config: StoredProfileConfig,
+  options: { profile?: string; setDefault?: boolean } = {}
+): Config {
+  const store = loadConfigStore();
+  const profile = normalizeProfile(options.profile);
+
+  store.profiles[profile] = normalizeStoredProfileConfig(config);
+
+  const normalizedDefault = normalizeProfile(store.defaultProfile);
+  if (options.setDefault || !store.profiles[normalizedDefault]) {
+    store.defaultProfile = profile;
+  } else {
+    store.defaultProfile = normalizedDefault;
+  }
+
+  writeConfigStore(store);
+  return { profile, ...store.profiles[profile] };
+}
+
+export function loadState(profile?: string): SubmitState {
+  const p = getStatePath(profile);
+  if (!existsSync(p)) return EMPTY_SUBMIT_STATE;
   try {
-    return JSON.parse(readFileSync(p, "utf-8")) as Config;
+    return normalizeSubmitState(JSON.parse(readFileSync(p, "utf-8")));
   } catch {
-    return null;
+    return EMPTY_SUBMIT_STATE;
   }
 }
 
-export function saveConfig(config: Config): void {
+export function saveState(state: SubmitState, profile?: string): void {
   mkdirSync(getConfigDir(), { recursive: true });
-  writeFileSync(getConfigPath(), JSON.stringify(config, null, 2), "utf-8");
+  writeFileSync(getStatePath(profile), JSON.stringify(state, null, 2) + "\n", "utf-8");
+}
+
+export function stateKey(sourceTool: string, sessionId: string): string {
+  return `${sourceTool}:${sessionId}`;
 }
 
-export function loadState(): SubmitState {
-  const p = getStatePath();
-  if (!existsSync(p)) return { chunks: {} };
+function readConfigFile(): unknown {
+  const p = getConfigPath();
+  if (!existsSync(p)) return null;
   try {
-    return JSON.parse(readFileSync(p, "utf-8")) as SubmitState;
+    return JSON.parse(readFileSync(p, "utf-8"));
   } catch {
-    return { chunks: {} };
+    return null;
   }
 }
 
-export function saveState(state: SubmitState): void {
+function writeConfigStore(store: ConfigStore): void {
+  const profiles = normalizeProfiles(store.profiles);
+  const requestedDefault = normalizeProfile(store.defaultProfile);
+  const defaultProfile = profiles[requestedDefault]
+    ? requestedDefault
+    : profiles[DEFAULT_PROFILE]
+      ? DEFAULT_PROFILE
+      : requestedDefault;
+
   mkdirSync(getConfigDir(), { recursive: true });
-  writeFileSync(getStatePath(), JSON.stringify(state, null, 2), "utf-8");
+  writeFileSync(
+    getConfigPath(),
+    JSON.stringify({ defaultProfile, profiles }, null, 2) + "\n",
+    "utf-8"
+  );
 }
 
-export function stateKey(sourceTool: string, sessionId: string): string {
-  return `${sourceTool}:${sessionId}`;
+function resolveProfileFromStore(store: ConfigStore, profile?: string): string {
+  if (profile) return normalizeProfile(profile);
+  if (process.env.TRACEMP_PROFILE) return normalizeProfile(process.env.TRACEMP_PROFILE);
+  return normalizeProfile(store.defaultProfile);
+}
+
+function profileSuffix(profile?: string): string {
+  const resolvedProfile = normalizeProfile(profile);
+  return resolvedProfile === DEFAULT_PROFILE ? "" : `.${resolvedProfile}`;
+}
+
+function normalizeProfile(profile?: string | null): string {
+  const trimmed = (profile ?? "").trim().toLowerCase();
+  if (!trimmed) return DEFAULT_PROFILE;
+
+  const normalized = trimmed
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/^-+/, "")
+    .replace(/-+$/, "");
+
+  return normalized || DEFAULT_PROFILE;
+}
+
+function normalizeProfiles(value: unknown): Record<string, StoredProfileConfig> {
+  if (!isRecord(value)) return {};
+
+  const profiles: Record<string, StoredProfileConfig> = {};
+  for (const [profile, config] of Object.entries(value)) {
+    if (!isStoredProfileConfig(config)) continue;
+    profiles[normalizeProfile(profile)] = normalizeStoredProfileConfig(config);
+  }
+  return profiles;
+}
+
+function normalizeStoredProfileConfig(config: StoredProfileConfig): StoredProfileConfig {
+  return {
+    apiKey: config.apiKey,
+    serverUrl: config.serverUrl,
+    email: config.email,
+  };
+}
+
+function normalizeSubmitState(value: unknown): SubmitState {
+  if (!isRecord(value)) {
+    return EMPTY_SUBMIT_STATE;
+  }
+
+  const chunks = isRecord(value.chunks)
+    ? Object.fromEntries(
+        Object.entries(value.chunks)
+          .filter((entry): entry is [string, number] => typeof entry[1] === "number")
+      )
+    : {};
+
+  const sessions = isRecord(value.sessions)
+    ? Object.fromEntries(
+        Object.entries(value.sessions)
+          .filter((entry): entry is [string, SessionUploadState] => isSessionUploadState(entry[1]))
+      )
+    : {};
+
+  return {
+    version: 2,
+    chunks,
+    sessions,
+  };
+}
+
+function isRecord(value: unknown): value is JsonRecord {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isStoredProfileConfig(value: unknown): value is StoredProfileConfig {
+  return isRecord(value)
+    && typeof value.apiKey === "string"
+    && typeof value.serverUrl === "string"
+    && typeof value.email === "string";
+}
+
+function isSessionUploadState(value: unknown): value is SessionUploadState {
+  return isRecord(value)
+    && (value.sourceTool === "claude_code" || value.sourceTool === "codex_cli" || value.sourceTool === "cursor")
+    && typeof value.sourceSessionId === "string"
+    && typeof value.locator === "string"
+    && typeof value.nextChunkIndex === "number"
+    && typeof value.openChunkStartTurn === "number"
+    && typeof value.lastSeenTurnCount === "number"
+    && (value.lastActivityAt === null || typeof value.lastActivityAt === "string")
+    && (value.lastFlushedTurnId === null || typeof value.lastFlushedTurnId === "string");
+}
+
+export function migrateSessionUploadState(value: SessionUploadState): SessionUploadState {
+  return {
+    ...value,
+    // Backward compat: existing sessions assume all submitted chunks are confirmed
+    confirmedChunkIndex: value.confirmedChunkIndex ?? value.nextChunkIndex,
+    confirmedOpenChunkStartTurn: value.confirmedOpenChunkStartTurn ?? value.openChunkStartTurn,
+    unconfirmedSince: value.unconfirmedSince ?? null,
+  };
 }

package/src/constants.ts

@@ -0,0 +1,18 @@
+export const CLI_NAME = "tracemp";
+export const DEFAULT_PROFILE = "prod";
+export const PROD_SERVER_URL = "https://trace-marketplace-api.fly.dev";
+export const DEV_SERVER_URL = "http://localhost:3001";
+
+export function defaultServerUrlForProfile(profile: string): string {
+  return profile === "dev" ? DEV_SERVER_URL : PROD_SERVER_URL;
+}
+
+export function inferProfileFromServerUrl(serverUrl: string): string {
+  return serverUrl === PROD_SERVER_URL ? DEFAULT_PROFILE : "dev";
+}
+
+export function loginCommandForProfile(profile: string): string {
+  return profile === DEFAULT_PROFILE
+    ? `${CLI_NAME} login`
+    : `${CLI_NAME} login --profile ${profile}`;
+}