ccsini 0.1.62 → 0.1.64

package/dist/index.js

@@ -27876,7 +27876,7 @@ function decodeProjectPath(encoded) {
 }
 
 // ../shared/src/constants.ts
-var DEFAULT_CATEGORY_PATTERNS, MERGE_STRATEGIES, NEVER_SYNC_PATTERNS, SESSION_SYNC_DEFAULTS, JWT_EXPIRY_SECONDS = 900, DAEMON_DEBOUNCE_MS = 5000, DAEMON_INTERVAL_MS = 30000, MAX_CONCURRENT_TRANSFERS = 50, BATCH_DOWNLOAD_SIZE = 20;
+var DEFAULT_CATEGORY_PATTERNS, MERGE_STRATEGIES, NEVER_SYNC_PATTERNS, SESSION_SYNC_DEFAULTS, JWT_EXPIRY_SECONDS = 900, DAEMON_DEBOUNCE_MS = 5000, DAEMON_INTERVAL_MS = 30000, MAX_CONCURRENT_TRANSFERS = 50, BATCH_DOWNLOAD_SIZE = 20, IPC_TIMEOUT_MS = 60000, IPC_SOCKET_NAME = "daemon.sock", IPC_PIPE_NAME = "ccsini-daemon";
 var init_constants = __esm(() => {
   DEFAULT_CATEGORY_PATTERNS = {
     session: ["projects/**/*.jsonl"],
@@ -28058,7 +28058,7 @@ var {
 } = import__.default;
 
 // src/version.ts
-var VERSION = "0.1.62";
+var VERSION = "0.1.64";
 
 // src/commands/init.ts
 init_source();
@@ -30116,14 +30116,14 @@ init_auth();
 init_auth();
 init_src();
 import { readFile as readFile8, writeFile as writeFile9 } from "fs/promises";
-import { join as join12 } from "path";
-import { platform as platform4 } from "os";
+import { join as join13 } from "path";
+import { platform as platform5 } from "os";
 import { spawn as spawn3 } from "child_process";
 
 // src/daemon/runner.ts
 import { readFile as readFile7, writeFile as writeFile8 } from "fs/promises";
-import { join as join11 } from "path";
-import { platform as platform3 } from "os";
+import { join as join12 } from "path";
+import { platform as platform4 } from "os";
 import { appendFileSync } from "fs";
 init_auth();
 
@@ -31739,11 +31739,13 @@ function watch(paths, options = {}) {
 }
 
 // src/daemon/watcher.ts
+import { relative as relative4 } from "path";
 init_src();
 function startWatcher(onSync) {
   const claudeDir = getClaudeDir();
   let debounceTimer = null;
   let syncing = false;
+  const dirtyPaths = new Set;
   const watcher = watch(claudeDir, {
     ignored: NEVER_SYNC_PATTERNS.map((p) => `**/${p}`),
     persistent: true,
@@ -31767,30 +31769,135 @@ function startWatcher(onSync) {
       }
     }, DAEMON_DEBOUNCE_MS);
   };
-  watcher.on("change", triggerSync);
-  watcher.on("add", triggerSync);
-  watcher.on("unlink", triggerSync);
+  const trackAndSync = (filePath) => {
+    dirtyPaths.add(relative4(claudeDir, filePath));
+    triggerSync();
+  };
+  watcher.on("change", trackAndSync);
+  watcher.on("add", trackAndSync);
+  watcher.on("unlink", trackAndSync);
   return {
     stop: () => {
       if (debounceTimer)
         clearTimeout(debounceTimer);
       watcher.close();
+    },
+    hasDirty: () => dirtyPaths.size > 0,
+    getDirty: () => new Set(dirtyPaths),
+    clearDirty: () => dirtyPaths.clear()
+  };
+}
+
+// src/daemon/ipc.ts
+init_src();
+import { createServer, createConnection } from "net";
+import { join as join11 } from "path";
+import { platform as platform3 } from "os";
+import { rm } from "fs/promises";
+function getSocketPath(configDir) {
+  if (platform3() === "win32") {
+    return `\\\\.\\pipe\\${IPC_PIPE_NAME}`;
+  }
+  return join11(configDir, IPC_SOCKET_NAME);
+}
+function startIpcServer(configDir, handler) {
+  const socketPath = getSocketPath(configDir);
+  const server = createServer((conn) => {
+    let buffer = "";
+    conn.on("data", (chunk) => {
+      buffer += chunk.toString();
+      let newlineIdx;
+      while ((newlineIdx = buffer.indexOf(`
+`)) !== -1) {
+        const line = buffer.slice(0, newlineIdx).trim();
+        buffer = buffer.slice(newlineIdx + 1);
+        if (!line)
+          continue;
+        let cmd;
+        try {
+          cmd = JSON.parse(line);
+        } catch {
+          conn.write(JSON.stringify({ ok: false, error: "invalid JSON" }) + `
+`);
+          return;
+        }
+        handler(cmd).then((result) => {
+          conn.write(JSON.stringify(result) + `
+`);
+        }).catch((err) => {
+          conn.write(JSON.stringify({ ok: false, error: err.message }) + `
+`);
+        });
+      }
+    });
+    conn.on("error", () => {});
+  });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      rm(socketPath, { force: true }).then(() => server.listen(socketPath)).catch(() => {});
+    }
+  });
+  server.listen(socketPath);
+  return {
+    close: async () => {
+      return new Promise((resolve3) => {
+        server.close(() => {
+          rm(socketPath, { force: true }).then(() => resolve3()).catch(() => resolve3());
+        });
+      });
     }
   };
 }
+async function ipcPush(configDir) {
+  const socketPath = getSocketPath(configDir);
+  return new Promise((resolve3) => {
+    const timeout = setTimeout(() => {
+      conn.destroy();
+      resolve3(null);
+    }, IPC_TIMEOUT_MS);
+    const conn = createConnection(socketPath);
+    let buffer = "";
+    conn.on("connect", () => {
+      conn.write(JSON.stringify({ cmd: "push-now" }) + `
+`);
+    });
+    conn.on("data", (chunk) => {
+      buffer += chunk.toString();
+      const newlineIdx = buffer.indexOf(`
+`);
+      if (newlineIdx !== -1) {
+        const line = buffer.slice(0, newlineIdx).trim();
+        clearTimeout(timeout);
+        conn.destroy();
+        try {
+          resolve3(JSON.parse(line));
+        } catch {
+          resolve3(null);
+        }
+      }
+    });
+    conn.on("error", () => {
+      clearTimeout(timeout);
+      resolve3(null);
+    });
+    conn.on("close", () => {
+      clearTimeout(timeout);
+    });
+  });
+}
 
 // src/daemon/runner.ts
 init_src();
 init_src();
 var HEARTBEAT_INTERVAL_MS = 3 * 60 * 1000;
 function getStatusPath(configDir) {
-  return join11(configDir, "daemon.status.json");
+  return join12(configDir, "daemon.status.json");
 }
 function getLogPath(configDir) {
-  return join11(configDir, "daemon.log");
+  return join12(configDir, "daemon.log");
 }
 function getPidPath(configDir) {
-  return join11(configDir, "daemon.pid");
+  return join12(configDir, "daemon.pid");
 }
 function log(configDir, message2) {
   const ts = new Date().toISOString();
@@ -31801,7 +31908,7 @@ function log(configDir, message2) {
   } catch {}
 }
 async function getMasterKey(configDir) {
-  const cachedKeyPath = join11(configDir, ".cached-key");
+  const cachedKeyPath = join12(configDir, ".cached-key");
   const cached = await readFile7(cachedKeyPath);
   return new Uint8Array(cached);
 }
@@ -31854,6 +31961,7 @@ async function runDaemon() {
       const config = await loadKeys(configDir);
       const sessionOptions = await getSessionOptions(configDir);
       const result = await pushSync(client, masterKey, config.deviceName, configDir, undefined, sessionOptions, { skipConflictBackup: true });
+      watcher.clearDirty();
       status.lastPushAt = Date.now();
       status.pushCount++;
       status.lastError = null;
@@ -31916,7 +32024,7 @@ async function runDaemon() {
       const { unlink: unlink2 } = await import("fs/promises");
       const files = await listConflictFiles();
       for (const f of files) {
-        await unlink2(join11(configDir, f)).catch(() => {});
+        await unlink2(join12(configDir, f)).catch(() => {});
       }
       if (files.length > 0) {
         log(configDir, `Resolved ${files.length} conflict file(s) via dashboard`);
@@ -31945,6 +32053,41 @@ async function runDaemon() {
     }
   }
   const watcher = startWatcher(doPush);
+  const ipcServer = startIpcServer(configDir, async (cmd) => {
+    if (cmd.cmd === "push-now") {
+      if (!watcher.hasDirty()) {
+        return { ok: true, filesChanged: 0, durationMs: 0 };
+      }
+      const start = Date.now();
+      try {
+        const masterKey = await getMasterKey(configDir);
+        const client = await getAuthenticatedClient(configDir);
+        const config = await loadKeys(configDir);
+        const sessionOptions = await getSessionOptions(configDir);
+        const result = await pushSync(client, masterKey, config.deviceName, configDir, undefined, sessionOptions, { skipConflictBackup: true });
+        watcher.clearDirty();
+        status.lastPushAt = Date.now();
+        status.pushCount++;
+        status.lastError = null;
+        await writeStatus(configDir, status);
+        if (result.filesChanged > 0) {
+          log(configDir, `IPC Push: ${result.filesChanged} files (${result.durationMs}ms)`);
+        }
+        return {
+          ok: true,
+          filesChanged: result.filesChanged,
+          durationMs: Date.now() - start
+        };
+      } catch (e) {
+        status.lastError = e.message;
+        await writeStatus(configDir, status).catch(() => {});
+        log(configDir, `IPC Push error: ${e.message}`);
+        return { ok: false, error: e.message };
+      }
+    }
+    return { ok: false, error: "unknown command" };
+  });
+  log(configDir, "IPC server started");
   const pullInterval = setInterval(doPull, DAEMON_INTERVAL_MS);
   const heartbeatInterval = setInterval(doHeartbeat, HEARTBEAT_INTERVAL_MS);
   await doPull();
@@ -31952,24 +32095,25 @@ async function runDaemon() {
   const shutdown = async () => {
     log(configDir, "Daemon shutting down...");
     watcher.stop();
+    await ipcServer.close();
     clearInterval(pullInterval);
     clearInterval(heartbeatInterval);
-    const { rm } = await import("fs/promises");
-    await rm(getPidPath(configDir)).catch(() => {});
-    await rm(getStatusPath(configDir)).catch(() => {});
+    const { rm: rm2 } = await import("fs/promises");
+    await rm2(getPidPath(configDir)).catch(() => {});
+    await rm2(getStatusPath(configDir)).catch(() => {});
     log(configDir, "Daemon stopped");
     process.exit(0);
   };
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
-  if (platform3() === "win32") {
+  if (platform4() === "win32") {
     process.on("SIGBREAK", shutdown);
   }
 }
 
 // src/commands/auto.ts
 async function getMasterKey2(configDir) {
-  const cachedKeyPath = join12(configDir, ".cached-key");
+  const cachedKeyPath = join13(configDir, ".cached-key");
   try {
     const cached = await readFile8(cachedKeyPath);
     return new Uint8Array(cached);
@@ -31981,7 +32125,7 @@ async function getAuthenticatedClient2(configDir) {
   const config = await loadKeys(configDir);
   const privateKey = await importPrivateKey(config.devicePrivateKey);
   const jwt = await createDeviceJWT(privateKey, config.deviceId);
-  return new CcsiniClient(config.apiUrl, jwt);
+  return { client: new CcsiniClient(config.apiUrl, jwt), config };
 }
 async function ensureDaemon(configDir) {
   try {
@@ -31995,7 +32139,7 @@ async function ensureDaemon(configDir) {
     }
   } catch {}
   try {
-    const isWin = platform4() === "win32";
+    const isWin = platform5() === "win32";
     const child = isWin ? spawn3("cmd", ["/c", "start", "/B", "ccsini", "daemon", "_run"], {
       stdio: "ignore",
       windowsHide: true
@@ -32011,12 +32155,13 @@ function registerAutoCommands(program2) {
     const configDir = getConfigDir();
     if (!await configExists(configDir))
       return;
-    await ensureDaemon(configDir);
     try {
-      const masterKey = await getMasterKey2(configDir);
-      const client = await getAuthenticatedClient2(configDir);
-      const config = await loadKeys(configDir);
-      const storedSession = await loadSessionConfig(configDir);
+      const [, masterKey, { client, config }, storedSession] = await Promise.all([
+        ensureDaemon(configDir),
+        getMasterKey2(configDir),
+        getAuthenticatedClient2(configDir),
+        loadSessionConfig(configDir)
+      ]);
       const sessionOptions = {
         enabled: storedSession.enabled,
         maxPerProject: storedSession.maxPerProject,
@@ -32036,10 +32181,20 @@ function registerAutoCommands(program2) {
     if (!await configExists(configDir))
       return;
     try {
-      const masterKey = await getMasterKey2(configDir);
-      const client = await getAuthenticatedClient2(configDir);
-      const config = await loadKeys(configDir);
-      const storedSession = await loadSessionConfig(configDir);
+      const ipcResult = await ipcPush(configDir);
+      if (ipcResult) {
+        if (ipcResult.ok && ipcResult.filesChanged && ipcResult.filesChanged > 0) {
+          console.log(`[ccsini] Pushed ${ipcResult.filesChanged} files (${ipcResult.durationMs}ms) [daemon]`);
+        }
+        return;
+      }
+    } catch {}
+    try {
+      const [masterKey, { client, config }, storedSession] = await Promise.all([
+        getMasterKey2(configDir),
+        getAuthenticatedClient2(configDir),
+        loadSessionConfig(configDir)
+      ]);
       const sessionOptions = {
         enabled: storedSession.enabled,
         maxPerProject: storedSession.maxPerProject,
@@ -32075,7 +32230,7 @@ function registerAutoCommands(program2) {
     ]);
     const config = await loadKeys(configDir);
     const masterKey = await deriveKeyFromPassphrase(password, config.salt);
-    await writeFile9(join12(configDir, ".cached-key"), masterKey, {
+    await writeFile9(join13(configDir, ".cached-key"), masterKey, {
       mode: 384
     });
     console.log("Unlocked. Auto-sync is now active.");
@@ -32085,15 +32240,15 @@ function registerAutoCommands(program2) {
     if (!await configExists(configDir))
       return;
     try {
-      const client = await getAuthenticatedClient2(configDir);
+      const { client } = await getAuthenticatedClient2(configDir);
       await client.heartbeat();
     } catch {}
   });
   program2.command("lock").description("Remove cached encryption key").action(async () => {
     const configDir = getConfigDir();
-    const { rm } = await import("fs/promises");
+    const { rm: rm2 } = await import("fs/promises");
     try {
-      await rm(join12(configDir, ".cached-key"));
+      await rm2(join13(configDir, ".cached-key"));
       console.log("Locked. Auto-sync paused until next unlock.");
     } catch {
       console.log("Already locked.");
@@ -32104,7 +32259,7 @@ function registerAutoCommands(program2) {
 // src/commands/doctor.ts
 init_source();
 import { access as access2 } from "fs/promises";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 function registerDoctorCommand(program2) {
   program2.command("doctor").description("Diagnose ccsini setup and connectivity").action(async () => {
     const configDir = getConfigDir();
@@ -32146,7 +32301,7 @@ function registerDoctorCommand(program2) {
       allGood = false;
     }
     try {
-      await access2(join13(configDir, ".cached-key"));
+      await access2(join14(configDir, ".cached-key"));
       console.log(source_default.green("  \u2713 Auto-sync unlocked"));
     } catch {
       console.log(source_default.yellow("  \u26A0 Auto-sync locked (run 'ccsini unlock')"));
@@ -32265,9 +32420,9 @@ Uninstall failed. Try manually:`);
 init_auth();
 init_src();
 import { readFile as readFile9 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 async function getMasterKey3(configDir) {
-  const cachedKeyPath = join14(configDir, ".cached-key");
+  const cachedKeyPath = join15(configDir, ".cached-key");
   try {
     const cached = await readFile9(cachedKeyPath);
     return new Uint8Array(cached);
@@ -32546,7 +32701,7 @@ function registerHooksCommands(program2) {
 
 // src/commands/reset.ts
 init_auth();
-import { rm } from "fs/promises";
+import { rm as rm2 } from "fs/promises";
 function registerResetCommand(program2) {
   program2.command("reset").description("Wipe all server data and local config (full account reset)").action(async () => {
     const configDir = getConfigDir();
@@ -32588,7 +32743,7 @@ function registerResetCommand(program2) {
         spinner.warn("Could not wipe server data (device may have been removed from dashboard)");
       }
       const localSpinner = ora2("Removing local config...").start();
-      await rm(configDir, { recursive: true, force: true });
+      await rm2(configDir, { recursive: true, force: true });
       localSpinner.succeed("Local config removed");
       console.log(chalk2.green(`
 Account fully reset. Run 'ccsini init --token <token>' to start fresh.`));
@@ -32691,17 +32846,17 @@ function registerSessionsCommand(program2) {
 
 // src/commands/conflicts.ts
 import { readdir as readdir4, readFile as readFile10, unlink as unlink2, writeFile as writeFile10 } from "fs/promises";
-import { join as join15, relative as relative4 } from "path";
+import { join as join16, relative as relative5 } from "path";
 async function findConflictFiles(dir, base) {
   base = base ?? dir;
   const results = [];
   const entries = await readdir4(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const full = join15(dir, entry.name);
+    const full = join16(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...await findConflictFiles(full, base));
     } else if (entry.name.endsWith(".conflict")) {
-      results.push(relative4(base, full).split("\\").join("/"));
+      results.push(relative5(base, full).split("\\").join("/"));
     }
   }
   return results;
@@ -32726,14 +32881,14 @@ function registerConflictsCommand(program2) {
     console.log();
     if (opts.keep === "remote") {
       for (const file of conflictFiles) {
-        await unlink2(join15(claudeDir, file));
+        await unlink2(join16(claudeDir, file));
       }
       console.log(chalk2.green(`Resolved ${conflictFiles.length} conflict(s) \u2014 kept remote versions.`));
       return;
     }
     if (opts.keep === "local") {
       for (const file of conflictFiles) {
-        const conflictPath = join15(claudeDir, file);
+        const conflictPath = join16(claudeDir, file);
         const originalPath = conflictPath.replace(/\.conflict$/, "");
         const conflictContent = await readFile10(conflictPath);
         await writeFile10(originalPath, conflictContent);
@@ -32745,8 +32900,8 @@ function registerConflictsCommand(program2) {
     const inquirer2 = await Promise.resolve().then(() => (init_dist16(), exports_dist));
     for (const file of conflictFiles) {
       const original = file.replace(/\.conflict$/, "");
-      const conflictPath = join15(claudeDir, file);
-      const originalPath = join15(claudeDir, original);
+      const conflictPath = join16(claudeDir, file);
+      const originalPath = join16(claudeDir, original);
       const { action } = await inquirer2.default.prompt([
         {
           type: "list",
@@ -32782,8 +32937,8 @@ ${remaining.length} conflict(s) remaining.`));
 
 // src/commands/daemon.ts
 import { spawn as spawn4 } from "child_process";
-import { readFile as readFile11, rm as rm2 } from "fs/promises";
-import { platform as platform5 } from "os";
+import { readFile as readFile11, rm as rm3 } from "fs/promises";
+import { platform as platform6 } from "os";
 function isProcessRunning(pid) {
   try {
     process.kill(pid, 0);
@@ -32820,10 +32975,10 @@ function registerDaemonCommands(program2) {
       return;
     }
     if (existingPid !== null) {
-      await rm2(getPidPath(configDir)).catch(() => {});
-      await rm2(getStatusPath(configDir)).catch(() => {});
+      await rm3(getPidPath(configDir)).catch(() => {});
+      await rm3(getStatusPath(configDir)).catch(() => {});
     }
-    const isWin = platform5() === "win32";
+    const isWin = platform6() === "win32";
     const child = isWin ? spawn4("cmd", ["/c", "start", "/B", "ccsini", "daemon", "_run"], {
       stdio: "ignore",
       windowsHide: true
@@ -32848,15 +33003,15 @@ function registerDaemonCommands(program2) {
       return;
     }
     if (!isProcessRunning(pid)) {
-      await rm2(getPidPath(configDir)).catch(() => {});
-      await rm2(getStatusPath(configDir)).catch(() => {});
+      await rm3(getPidPath(configDir)).catch(() => {});
+      await rm3(getStatusPath(configDir)).catch(() => {});
       console.log("Daemon is not running (cleaned up stale PID file).");
       return;
     }
     try {
       process.kill(pid, "SIGTERM");
     } catch {
-      if (platform5() === "win32") {
+      if (platform6() === "win32") {
         const { execSync: execSync3 } = await import("child_process");
         try {
           execSync3(`taskkill /PID ${pid} /T /F`, { stdio: "ignore", timeout: 5000 });
@@ -32869,8 +33024,8 @@ function registerDaemonCommands(program2) {
         return;
       }
     }
-    await rm2(getPidPath(configDir)).catch(() => {});
-    await rm2(getStatusPath(configDir)).catch(() => {});
+    await rm3(getPidPath(configDir)).catch(() => {});
+    await rm3(getStatusPath(configDir)).catch(() => {});
     console.log("Daemon stopped.");
   });
   daemonCmd.command("status").description("Show daemon status").action(async () => {

package/package.json

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