ccsini 0.1.33 → 0.1.35

package/dist/index.js

@@ -27865,8 +27865,18 @@ var init_webapi = __esm(() => {
   init_verify4();
   init_sign4();
 });
+
+// ../shared/src/types.ts
+function decodeProjectPath(encoded) {
+  const driveMatch = encoded.match(/^([A-Za-z])--(.*)$/);
+  if (driveMatch) {
+    return `${driveMatch[1].toUpperCase()}:/${driveMatch[2].replace(/-/g, "/")}`;
+  }
+  return "/" + encoded.replace(/-/g, "/");
+}
+
 // ../shared/src/constants.ts
-var DEFAULT_CATEGORY_PATTERNS, MERGE_STRATEGIES, NEVER_SYNC_PATTERNS, JWT_EXPIRY_SECONDS = 900, MAX_CONCURRENT_TRANSFERS = 50;
+var DEFAULT_CATEGORY_PATTERNS, MERGE_STRATEGIES, NEVER_SYNC_PATTERNS, SESSION_SYNC_DEFAULTS, JWT_EXPIRY_SECONDS = 900, MAX_CONCURRENT_TRANSFERS = 50;
 var init_constants = __esm(() => {
   DEFAULT_CATEGORY_PATTERNS = {
     session: ["projects/**/*.jsonl"],
@@ -27910,7 +27920,6 @@ var init_constants = __esm(() => {
     "**/node_modules/**",
     "**/cache/**",
     "**/tool-results/**",
-    "projects/**/*.jsonl",
     "plugins/**",
     "plans/**",
     "todos/**",
@@ -27920,8 +27929,14 @@ var init_constants = __esm(() => {
     "**/dist/**",
     "**/.git/**",
     "**/*.bak",
-    "settings.*.json"
+    "settings.*.json",
+    "history.jsonl"
   ];
+  SESSION_SYNC_DEFAULTS = {
+    enabled: false,
+    maxPerProject: 3,
+    maxFileSize: 50000000
+  };
 });
 
 // ../shared/src/index.ts
@@ -28003,7 +28018,7 @@ var {
 } = import__.default;
 
 // src/version.ts
-var VERSION = "0.1.33";
+var VERSION = "0.1.35";
 
 // src/commands/init.ts
 init_source();
@@ -28674,6 +28689,7 @@ function decryptFile(masterKey, filePath, ciphertext) {
 }
 
 // src/core/keystore.ts
+init_src();
 import { readFile, writeFile, mkdir, access } from "fs/promises";
 import { join } from "path";
 import { homedir } from "os";
@@ -28719,6 +28735,31 @@ async function loadKeys(configDir) {
     apiUrl: config.apiUrl
   };
 }
+async function loadSessionConfig(configDir) {
+  const dir = configDir ?? getConfigDir();
+  try {
+    const configRaw = await readFile(join(dir, "config.json"), "utf-8");
+    const config = JSON.parse(configRaw);
+    return {
+      enabled: config.syncSessions ?? SESSION_SYNC_DEFAULTS.enabled,
+      maxPerProject: config.sessionsPerProject ?? SESSION_SYNC_DEFAULTS.maxPerProject
+    };
+  } catch {
+    return {
+      enabled: SESSION_SYNC_DEFAULTS.enabled,
+      maxPerProject: SESSION_SYNC_DEFAULTS.maxPerProject
+    };
+  }
+}
+async function saveSessionConfig(configDir, sessionConfig) {
+  const dir = configDir ?? getConfigDir();
+  const configPath = join(dir, "config.json");
+  const configRaw = await readFile(configPath, "utf-8");
+  const config = JSON.parse(configRaw);
+  config.syncSessions = sessionConfig.enabled;
+  config.sessionsPerProject = sessionConfig.maxPerProject;
+  await writeFile(configPath, JSON.stringify(config, null, 2));
+}
 
 // src/core/schema.ts
 init_src();
@@ -29017,6 +29058,17 @@ class CcsiniClient {
     if (!res.ok)
       throw new Error("Failed to wipe account data");
   }
+  async putProjects(projects, device) {
+    const res = await fetch(`${this.apiUrl}/api/sync/projects`, {
+      method: "PUT",
+      headers: this.getHeaders(),
+      body: JSON.stringify({ projects, device, timestamp: Date.now() })
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Failed to send projects (${res.status}): ${text}`);
+    }
+  }
   async resetAll() {
     const res = await fetch(`${this.apiUrl}/api/sync/reset`, {
       method: "DELETE",
@@ -29061,12 +29113,48 @@ function categorizeFile(relativePath) {
   return "unknown";
 }
 function matchGlobPattern(path2, pattern) {
-  const regex2 = pattern.replace(/\./g, "\\.").replace(/\*\*\//g, "(.+/)?").replace(/\*\*/g, ".*").replace(/(?<!\.)(\*)/g, "[^/]*");
+  const regex2 = pattern.replace(/\*\*\//g, "\x00DIR\x00").replace(/\*\*/g, "\x00STAR\x00").replace(/\./g, "\\.").replace(/\*/g, "[^/]*").replace(/\0DIR\0/g, "(.+/)?").replace(/\0STAR\0/g, ".*");
   return new RegExp(`^${regex2}$`).test(path2);
 }
 function isExcluded(relativePath) {
   return NEVER_SYNC_PATTERNS.some((pattern) => matchGlobPattern(relativePath, pattern));
 }
+function isSessionFile(relativePath) {
+  return matchGlobPattern(relativePath, "projects/**/*.jsonl");
+}
+function filterSessionFiles(files, options) {
+  const sessions = [];
+  const nonSessions = [];
+  for (const file of files) {
+    if (isSessionFile(file.relativePath)) {
+      sessions.push(file);
+    } else {
+      nonSessions.push(file);
+    }
+  }
+  if (!options.enabled) {
+    return nonSessions;
+  }
+  const byProject = new Map;
+  for (const file of sessions) {
+    if (file.size > options.maxFileSize)
+      continue;
+    const parts = file.relativePath.split("/");
+    const projectKey = parts.slice(0, 2).join("/");
+    let group = byProject.get(projectKey);
+    if (!group) {
+      group = [];
+      byProject.set(projectKey, group);
+    }
+    group.push(file);
+  }
+  const kept = [];
+  for (const group of byProject.values()) {
+    group.sort((a, b) => b.modified - a.modified);
+    kept.push(...group.slice(0, options.maxPerProject));
+  }
+  return [...nonSessions, ...kept];
+}
 async function hashFile(filePath) {
   const content = await readFile4(filePath);
   return createHash("sha256").update(content).digest("hex");
@@ -29101,18 +29189,28 @@ async function scanDir(baseDir, currentDir, results, onProgress) {
     }
   }
 }
-async function scanClaudeDir(claudeDir, onProgress) {
+async function scanClaudeDir(claudeDir, onProgress, sessionOptions) {
   const progress = onProgress ?? (() => {});
   const results = [];
   progress("Scanning local files...");
   await scanDir(claudeDir, claudeDir, results, progress);
   progress(`Scan complete: ${results.length} files found`);
-  return results;
+  const sessionOpts = sessionOptions ?? {
+    enabled: SESSION_SYNC_DEFAULTS.enabled,
+    maxPerProject: SESSION_SYNC_DEFAULTS.maxPerProject,
+    maxFileSize: SESSION_SYNC_DEFAULTS.maxFileSize
+  };
+  const filtered = filterSessionFiles(results, sessionOpts);
+  if (filtered.length !== results.length) {
+    const diff = results.length - filtered.length;
+    progress(`Filtered ${diff} session files (${filtered.length} files to sync)`);
+  }
+  return filtered;
 }
 
 // src/core/manifest.ts
-async function generateManifest(claudeDir, deviceName, onProgress) {
-  const files = await scanClaudeDir(claudeDir, onProgress);
+async function generateManifest(claudeDir, deviceName, onProgress, sessionOptions) {
+  const files = await scanClaudeDir(claudeDir, onProgress, sessionOptions);
   const entries = {};
   for (const file of files) {
     entries[file.relativePath] = {
@@ -29216,19 +29314,46 @@ function mergeLastWriteWins(localContent, remoteContent, localModified, remoteMo
 
 // src/core/sync.ts
 init_src();
+init_src();
 function blobKey(filePath, contentHash) {
   return createHash2("sha256").update(`${filePath}:${contentHash}`).digest("hex");
 }
 function getClaudeDir() {
   return join6(homedir2(), ".claude");
 }
-async function pushSync(client, masterKey, deviceName, configDir, onProgress) {
+function extractProjects(manifest) {
+  const projectMap = new Map;
+  for (const [path2, entry] of Object.entries(manifest.files)) {
+    const match = path2.match(/^projects\/([^/]+)\//);
+    if (!match)
+      continue;
+    const encoded = match[1];
+    let proj = projectMap.get(encoded);
+    if (!proj) {
+      proj = { fileCount: 0, totalSize: 0, categories: new Set };
+      projectMap.set(encoded, proj);
+    }
+    proj.fileCount++;
+    proj.totalSize += entry.size;
+    proj.categories.add(entry.category);
+  }
+  return Array.from(projectMap.entries()).map(([encoded, data]) => ({
+    encodedPath: encoded,
+    decodedPath: decodeProjectPath(encoded),
+    name: encoded.split("-").pop() || encoded,
+    fileCount: data.fileCount,
+    totalSize: data.totalSize,
+    categories: Array.from(data.categories),
+    lastSyncedAt: manifest.timestamp
+  }));
+}
+async function pushSync(client, masterKey, deviceName, configDir, onProgress, sessionOptions) {
   const start = Date.now();
   const claudeDir = getClaudeDir();
   const errors2 = [];
   let bytesTransferred = 0;
   const progress = onProgress ?? (() => {});
-  const localManifest = await generateManifest(claudeDir, deviceName, progress);
+  const localManifest = await generateManifest(claudeDir, deviceName, progress, sessionOptions);
   const fileCount = Object.keys(localManifest.files).length;
   progress(`Scanned ${fileCount} files`);
   progress("Fetching remote manifest...");
@@ -29291,6 +29416,12 @@ async function pushSync(client, masterKey, deviceName, configDir, onProgress) {
     bytesTransferred,
     durationMs
   });
+  try {
+    const projects = extractProjects(localManifest);
+    if (projects.length > 0) {
+      await client.putProjects(projects, deviceName);
+    }
+  } catch {}
   return {
     action: "push",
     filesChanged: toPush.length,
@@ -29299,7 +29430,7 @@ async function pushSync(client, masterKey, deviceName, configDir, onProgress) {
     errors: errors2
   };
 }
-async function pullSync(client, masterKey, deviceName, configDir, onProgress) {
+async function pullSync(client, masterKey, deviceName, configDir, onProgress, sessionOptions) {
   const start = Date.now();
   const claudeDir = getClaudeDir();
   const errors2 = [];
@@ -29335,14 +29466,20 @@ async function pullSync(client, masterKey, deviceName, configDir, onProgress) {
   const localManifest = await loadManifest(configDir);
   progress("Comparing manifests...");
   const diffs = diffManifests(localManifest, remoteManifest);
-  const toPull = diffs.filter((d) => (d.action === "pull" || d.action === "merge") && !isExcluded(d.path));
+  const sessionsEnabled = sessionOptions?.enabled ?? SESSION_SYNC_DEFAULTS.enabled;
+  const toPull = diffs.filter((d) => (d.action === "pull" || d.action === "merge") && !isExcluded(d.path) && (sessionsEnabled || !isSessionFile(d.path)));
   progress(`${toPull.length} files to pull`);
   let downloaded = 0;
   const chunks = chunkArray(toPull, MAX_CONCURRENT_TRANSFERS);
   for (const chunk of chunks) {
     await Promise.all(chunk.map(async (diff) => {
       try {
-        const encrypted = await client.downloadBlob(blobKey(diff.path, diff.remoteHash));
+        let encrypted;
+        try {
+          encrypted = await client.downloadBlob(blobKey(diff.path, diff.remoteHash));
+        } catch {
+          encrypted = await client.downloadBlob(diff.remoteHash);
+        }
         bytesTransferred += encrypted.length;
         const decrypted = decryptFile(masterKey, diff.path, encrypted);
         if (diff.action === "merge" && diff.localHash) {
@@ -29608,6 +29745,7 @@ function detectPlatform() {
 // src/commands/auto.ts
 init_auth();
 init_auth();
+init_src();
 import { readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
 import { join as join8 } from "path";
 async function getMasterKey(configDir) {
@@ -29634,7 +29772,13 @@ function registerAutoCommands(program2) {
       const masterKey = await getMasterKey(configDir);
       const client = await getAuthenticatedClient(configDir);
       const config = await loadKeys(configDir);
-      const result = await pullSync(client, masterKey, config.deviceName, configDir);
+      const storedSession = await loadSessionConfig(configDir);
+      const sessionOptions = {
+        enabled: storedSession.enabled,
+        maxPerProject: storedSession.maxPerProject,
+        maxFileSize: SESSION_SYNC_DEFAULTS.maxFileSize
+      };
+      const result = await pullSync(client, masterKey, config.deviceName, configDir, undefined, sessionOptions);
       if (result.filesChanged > 0) {
         console.log(`[ccsini] Pulled ${result.filesChanged} files (${result.durationMs}ms)`);
       }
@@ -29648,7 +29792,13 @@ function registerAutoCommands(program2) {
       const masterKey = await getMasterKey(configDir);
       const client = await getAuthenticatedClient(configDir);
       const config = await loadKeys(configDir);
-      const result = await pushSync(client, masterKey, config.deviceName, configDir);
+      const storedSession = await loadSessionConfig(configDir);
+      const sessionOptions = {
+        enabled: storedSession.enabled,
+        maxPerProject: storedSession.maxPerProject,
+        maxFileSize: SESSION_SYNC_DEFAULTS.maxFileSize
+      };
+      const result = await pushSync(client, masterKey, config.deviceName, configDir, undefined, sessionOptions);
       if (result.filesChanged > 0) {
         console.log(`[ccsini] Pushed ${result.filesChanged} files (${result.durationMs}ms)`);
       }
@@ -29840,6 +29990,7 @@ Uninstall failed. Try manually:`);
 
 // src/commands/sync.ts
 init_auth();
+init_src();
 import { readFile as readFile8 } from "fs/promises";
 import { join as join10 } from "path";
 async function getMasterKey2(configDir) {
@@ -29879,7 +30030,7 @@ function formatBytes(bytes) {
 }
 function registerSyncCommands(program2) {
   const syncCmd = program2.command("sync").description("Sync management commands");
-  syncCmd.command("push").description("Push local changes to cloud").action(async () => {
+  syncCmd.command("push").description("Push local changes to cloud").option("--with-sessions", "Include session files in sync").option("--no-sessions", "Exclude session files from sync").action(async (opts) => {
     const configDir = getConfigDir();
     if (!await configExists(configDir)) {
       console.error("Not initialized. Run 'ccsini init' first.");
@@ -29891,10 +30042,16 @@ function registerSyncCommands(program2) {
       const masterKey = await getMasterKey2(configDir);
       const client = await getAuthenticatedClient2(configDir);
       const config = await loadKeys(configDir);
+      const storedSession = await loadSessionConfig(configDir);
+      const sessionOptions = {
+        enabled: opts.withSessions ? true : opts.sessions === false ? false : storedSession.enabled,
+        maxPerProject: storedSession.maxPerProject,
+        maxFileSize: SESSION_SYNC_DEFAULTS.maxFileSize
+      };
       const spinner = ora2("Scanning files...").start();
       const result = await pushSync(client, masterKey, config.deviceName, configDir, (msg) => {
         spinner.text = msg;
-      });
+      }, sessionOptions);
       if (result.errors.length > 0) {
         spinner.warn("Push completed with errors");
         for (const err of result.errors) {
@@ -29904,12 +30061,15 @@ function registerSyncCommands(program2) {
         spinner.succeed("Push complete");
       }
       console.log(chalk2.dim(`  ${result.filesChanged} files changed, ${formatBytes(result.bytesTransferred)} transferred in ${result.durationMs}ms`));
+      if (sessionOptions.enabled) {
+        console.log(chalk2.dim("  Sessions: enabled"));
+      }
     } catch (e) {
       console.error(`Push failed: ${e.message}`);
       process.exit(1);
     }
   });
-  syncCmd.command("pull").description("Pull changes from cloud").action(async () => {
+  syncCmd.command("pull").description("Pull changes from cloud").option("--with-sessions", "Include session files in sync").option("--no-sessions", "Exclude session files from sync").action(async (opts) => {
     const configDir = getConfigDir();
     if (!await configExists(configDir)) {
       console.error("Not initialized. Run 'ccsini init' first.");
@@ -29921,10 +30081,16 @@ function registerSyncCommands(program2) {
       const masterKey = await getMasterKey2(configDir);
       const client = await getAuthenticatedClient2(configDir);
       const config = await loadKeys(configDir);
+      const storedSession = await loadSessionConfig(configDir);
+      const sessionOptions = {
+        enabled: opts.withSessions ? true : opts.sessions === false ? false : storedSession.enabled,
+        maxPerProject: storedSession.maxPerProject,
+        maxFileSize: SESSION_SYNC_DEFAULTS.maxFileSize
+      };
       const spinner = ora2("Pulling from cloud...").start();
       const result = await pullSync(client, masterKey, config.deviceName, configDir, (msg) => {
         spinner.text = msg;
-      });
+      }, sessionOptions);
       if (result.errors.length > 0) {
         spinner.warn("Pull completed with errors");
         for (const err of result.errors) {
@@ -29934,6 +30100,9 @@ function registerSyncCommands(program2) {
         spinner.succeed("Pull complete");
       }
       console.log(chalk2.dim(`  ${result.filesChanged} files changed, ${formatBytes(result.bytesTransferred)} transferred in ${result.durationMs}ms`));
+      if (sessionOptions.enabled) {
+        console.log(chalk2.dim("  Sessions: enabled"));
+      }
     } catch (e) {
       console.error(`Pull failed: ${e.message}`);
       process.exit(1);
@@ -30151,6 +30320,95 @@ Account fully reset. Run 'ccsini init --token <token>' to start fresh.`));
   });
 }
 
+// src/commands/sessions.ts
+init_src();
+function formatBytes2(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function registerSessionsCommand(program2) {
+  const sessionsCmd = program2.command("sessions").description("Configure session sync (continue conversations across devices)");
+  sessionsCmd.command("enable").description("Enable session sync").option("-n, --per-project <count>", "Max sessions per project", String(SESSION_SYNC_DEFAULTS.maxPerProject)).action(async (opts) => {
+    const configDir = getConfigDir();
+    if (!await configExists(configDir)) {
+      console.error("Not initialized. Run 'ccsini init' first.");
+      process.exit(1);
+    }
+    const maxPerProject = parseInt(opts.perProject, 10);
+    if (isNaN(maxPerProject) || maxPerProject < 1) {
+      console.error("--per-project must be a positive integer");
+      process.exit(1);
+    }
+    await saveSessionConfig(configDir, {
+      enabled: true,
+      maxPerProject
+    });
+    console.log(`Session sync enabled (${maxPerProject} sessions per project)`);
+  });
+  sessionsCmd.command("disable").description("Disable session sync").action(async () => {
+    const configDir = getConfigDir();
+    if (!await configExists(configDir)) {
+      console.error("Not initialized. Run 'ccsini init' first.");
+      process.exit(1);
+    }
+    const current = await loadSessionConfig(configDir);
+    await saveSessionConfig(configDir, {
+      enabled: false,
+      maxPerProject: current.maxPerProject
+    });
+    console.log("Session sync disabled");
+  });
+  sessionsCmd.command("status").description("Show session sync status and preview").action(async () => {
+    const configDir = getConfigDir();
+    if (!await configExists(configDir)) {
+      console.error("Not initialized. Run 'ccsini init' first.");
+      process.exit(1);
+    }
+    const chalk2 = (await Promise.resolve().then(() => (init_source(), exports_source))).default;
+    const ora2 = (await Promise.resolve().then(() => (init_ora(), exports_ora))).default;
+    const sessionConfig = await loadSessionConfig(configDir);
+    console.log(chalk2.bold("Session Sync"));
+    console.log(`  Status:         ${sessionConfig.enabled ? chalk2.green("enabled") : chalk2.yellow("disabled")}`);
+    console.log(`  Per project:    ${sessionConfig.maxPerProject}`);
+    console.log(`  Max file size:  ${formatBytes2(SESSION_SYNC_DEFAULTS.maxFileSize)}`);
+    const spinner = ora2("Scanning session files...").start();
+    try {
+      const claudeDir = getClaudeDir();
+      const enabledOpts = {
+        enabled: true,
+        maxPerProject: sessionConfig.maxPerProject,
+        maxFileSize: SESSION_SYNC_DEFAULTS.maxFileSize
+      };
+      const withSessions = await scanClaudeDir(claudeDir, undefined, enabledOpts);
+      const sessionFiles = withSessions.filter((f) => isSessionFile(f.relativePath));
+      const disabledOpts = {
+        enabled: false,
+        maxPerProject: sessionConfig.maxPerProject,
+        maxFileSize: SESSION_SYNC_DEFAULTS.maxFileSize
+      };
+      const withoutSessions = await scanClaudeDir(claudeDir, undefined, disabledOpts);
+      spinner.stop();
+      const totalSessionSize = sessionFiles.reduce((sum, f) => sum + f.size, 0);
+      const projects = new Set(sessionFiles.map((f) => f.relativePath.split("/").slice(0, 2).join("/")));
+      console.log(chalk2.bold(`
+  Preview`));
+      console.log(`  Projects:       ${projects.size}`);
+      console.log(`  Sessions:       ${sessionFiles.length} files`);
+      console.log(`  Session size:   ${formatBytes2(totalSessionSize)}`);
+      console.log(`  Other files:    ${withoutSessions.length}`);
+      if (!sessionConfig.enabled) {
+        console.log(chalk2.dim(`
+  Run 'ccsini sessions enable' to start syncing sessions`));
+      }
+    } catch (e) {
+      spinner.fail(`Scan failed: ${e.message}`);
+    }
+  });
+}
+
 // src/index.ts
 var program2 = new Command;
 program2.name("ccsini").description("Claude Code seamless sync across devices").version(VERSION);
@@ -30161,6 +30419,7 @@ registerSelfCommands(program2);
 registerSyncCommands(program2);
 registerHooksCommands(program2);
 registerResetCommand(program2);
+registerSessionsCommand(program2);
 program2.command("version").description("Show current version").action(() => {
   console.log(VERSION);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccsini",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "description": "Claude Code seamless sync across devices",
   "type": "module",
   "bin": {