bisync-cli 0.0.7 → 0.0.9

package/dist/bisync.js

@@ -2,12 +2,16 @@
 // @bun
 
 // src/bin.ts
+import { createHash } from "crypto";
 import { createWriteStream, mkdirSync } from "fs";
 import { readdir, stat } from "fs/promises";
 import { homedir } from "os";
-import { join, resolve } from "path";
+import { join, relative, resolve, sep } from "path";
+import { createInterface } from "readline";
+import { setTimeout } from "timers/promises";
+import { parseArgs as parseArgsUtil } from "util";
 // package.json
-var version = "0.0.7";
+var version = "0.0.9";
 
 // src/bin.ts
 var CONFIG_DIR = join(homedir(), ".agent-bisync");
@@ -17,17 +21,40 @@ var CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
 var DEBUG_LOG_PATH = join(CONFIG_DIR, "debug.log");
 var CLIENT_ID = "bisync-cli";
 var MAX_LINES_PER_BATCH = 200;
-var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
-var usage = () => {
+var MAX_STATE_CHUNKS_PER_BATCH = 50;
+var MAX_STATE_CHUNK_SIZE = 256 * 1024;
+var parseArgs = () => {
+  const parsed = parseArgsUtil({
+    args: process.argv.slice(2),
+    options: {
+      verbose: { type: "boolean" },
+      version: { type: "boolean" },
+      help: { type: "boolean" },
+      force: { type: "boolean" },
+      "site-url": { type: "string" },
+      siteUrl: { type: "string" }
+    },
+    allowPositionals: true
+  });
+  const values = parsed.values;
+  const positionals = parsed.positionals;
+  return { values, positionals };
+};
+var printUsage = () => {
   console.log(`bisync <command>
 
 Commands:
-  setup --site-url <url>   Configure hooks and authenticate
-  verify                   Check auth and list session ids
-  hook <HOOK>              Handle Claude hook input (stdin JSON)
+  auth login --site-url <url>   Authenticate via device flow
+  auth logout                   Sign out of the CLI
+  session list                  List session ids
+  setup --site-url <url>        Configure hooks and authenticate
+  hook <HOOK>                   Handle Claude hook input (stdin JSON)
 
 Global options:
   --verbose                Enable verbose logging
+  --help                   Show usage
+
+Version: ${version} (Bun ${Bun.version})
 `);
 };
 var LOG_LEVEL = "info";
@@ -46,14 +73,19 @@ var getDebugLogStream = () => {
     return null;
   }
 };
-var log = (level, message) => {
-  const logMessage = `[bisync][${level}] ${message}`;
-  getDebugLogStream()?.write(`[${new Date().toISOString()}] ${logMessage}
+var log = (level, message, fields) => {
+  let logMessage = `[${level}] ${message}`;
+  if (fields) {
+    for (const [key, value] of Object.entries(fields)) {
+      logMessage += ` ${key}=${value}`;
+    }
+  }
+  getDebugLogStream()?.write(`[${new Date().toISOString()}]${logMessage}
 `);
   if (level < LOG_LEVEL) {
     return;
   }
-  console.log(logMessage);
+  console.log(`[bisync]${logMessage}`);
 };
 var readConfig = async () => {
   return await Bun.file(CONFIG_PATH).json();
@@ -63,9 +95,34 @@ var writeConfig = async (config) => {
     createPath: true
   });
 };
+var readConfigIfExists = async () => {
+  const configFile = Bun.file(CONFIG_PATH);
+  if (!await configFile.exists()) {
+    return null;
+  }
+  try {
+    return await configFile.json();
+  } catch {
+    return null;
+  }
+};
+var promptYesNo = async (question, defaultValue) => {
+  if (!process.stdin.isTTY) {
+    log("warn", `${question} Using default ${defaultValue ? "yes" : "no"} (stdin not interactive).`);
+    return defaultValue;
+  }
+  const suffix = defaultValue ? " [Y/n] " : " [y/N] ";
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve2) => rl.question(`${question}${suffix}`, resolve2));
+  rl.close();
+  const normalized = answer.trim().toLowerCase();
+  if (!normalized) {
+    return defaultValue;
+  }
+  return normalized === "y" || normalized === "yes";
+};
 var resolveSiteUrl = (args) => {
-  const argIndex = args.findIndex((value) => value === "--site-url" || value === "--siteUrl");
-  const argValue = argIndex >= 0 ? args[argIndex + 1] : undefined;
+  const argValue = args["site-url"] ?? args.siteUrl;
   const envValue = process.env.BISYNC_SITE_URL;
   if (argValue) {
     return { siteUrl: argValue, source: "arg" };
@@ -73,16 +130,6 @@ var resolveSiteUrl = (args) => {
   if (envValue) {
     return { siteUrl: envValue, source: "env" };
   }
-  const viteConvexUrl = process.env.VITE_CONVEX_URL;
-  if (viteConvexUrl?.endsWith(".convex.cloud")) {
-    return {
-      siteUrl: viteConvexUrl.replace(".convex.cloud", ".convex.site"),
-      source: "vite"
-    };
-  }
-  if (viteConvexUrl) {
-    return { siteUrl: viteConvexUrl, source: "vite" };
-  }
   return { siteUrl: null, source: "missing" };
 };
 var openBrowser = async (url) => {
@@ -93,8 +140,21 @@ var openBrowser = async (url) => {
     await Bun.$`open ${url}`;
   } catch {}
 };
+var buildVerificationUrl = (data) => {
+  if (data.verification_uri_complete) {
+    return data.verification_uri_complete;
+  }
+  try {
+    const url = new URL(data.verification_uri);
+    url.searchParams.set("user_code", data.user_code);
+    return url.toString();
+  } catch {
+    const separator = data.verification_uri.includes("?") ? "&" : "?";
+    return `${data.verification_uri}${separator}user_code=${encodeURIComponent(data.user_code)}`;
+  }
+};
 var deviceAuthFlow = async (siteUrl) => {
-  log("debug", `device auth start siteUrl=${siteUrl}`);
+  log("debug", `device auth start`, { siteUrl });
   const codeResponse = await fetch(`${siteUrl}/api/auth/device/code`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -102,20 +162,20 @@ var deviceAuthFlow = async (siteUrl) => {
   });
   if (!codeResponse.ok) {
     const errorText = await codeResponse.text();
-    log("debug", `device code request failed status=${codeResponse.status}`);
+    log("debug", `device code request failed`, { status: codeResponse.status });
     throw new Error(`Device code request failed: ${codeResponse.status} ${errorText}`);
   }
-  log("debug", `device code request ok status=${codeResponse.status}`);
+  log("debug", `device code request ok`, { status: codeResponse.status });
   const codeData = await codeResponse.json();
-  const verificationUrl = codeData.verification_uri_complete ?? codeData.verification_uri;
-  log("info", `Authorize this device: ${verificationUrl}`);
-  log("info", `User code: ${codeData.user_code}`);
+  const verificationUrl = buildVerificationUrl(codeData);
+  console.log(`Authorize this device: ${verificationUrl}`);
+  console.log(`Your Verification Code: ${codeData.user_code}`);
   await openBrowser(verificationUrl);
   const intervalMs = Math.max(1, codeData.interval ?? 5) * 1000;
-  log("debug", `device auth polling intervalMs=${intervalMs}`);
+  log("debug", `device auth polling`, { intervalMs });
   let pollDelay = intervalMs;
   while (true) {
-    await sleep(pollDelay);
+    await setTimeout(pollDelay);
     const tokenResponse = await fetch(`${siteUrl}/api/auth/device/token`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -127,7 +187,7 @@ var deviceAuthFlow = async (siteUrl) => {
     });
     const tokenData = await tokenResponse.json();
     if (tokenResponse.ok && tokenData.access_token) {
-      log("debug", `device auth success status=${tokenResponse.status}`);
+      log("debug", `device auth success`, { status: tokenResponse.status });
       return tokenData.access_token;
     }
     if (tokenData.error === "authorization_pending") {
@@ -135,10 +195,13 @@ var deviceAuthFlow = async (siteUrl) => {
     }
     if (tokenData.error === "slow_down") {
       pollDelay += 1000;
-      log("debug", `device auth slow_down nextDelayMs=${pollDelay}`);
+      log("debug", `device auth slow_down`, { nextDelayMs: pollDelay });
       continue;
     }
-    log("debug", `device auth failed status=${tokenResponse.status} error=${tokenData.error ?? "unknown"}`);
+    log("debug", `device auth failed`, {
+      status: tokenResponse.status,
+      error: tokenData.error ?? "unknown"
+    });
     throw new Error(`Device auth failed: ${tokenData.error ?? "unknown"} ${tokenData.error_description ?? ""}`.trim());
   }
 };
@@ -159,10 +222,10 @@ var ensureHookEntry = (entries, next) => {
   return entries;
 };
 var mergeSettings = async () => {
-  log("debug", `mergeSettings path=${CLAUDE_SETTINGS_PATH}`);
+  log("debug", `mergeSettings`, { path: CLAUDE_SETTINGS_PATH });
   const settingsFile = Bun.file(CLAUDE_SETTINGS_PATH);
   const settingsExists = await settingsFile.exists();
-  log("debug", `mergeSettings existing=${settingsExists}`);
+  log("debug", `mergeSettings`, { existing: settingsExists });
   let current = {};
   if (settingsExists) {
     try {
@@ -201,9 +264,14 @@ var mergeSettings = async () => {
   log("debug", `mergeSettings wrote settings`);
   try {
     const info = await stat(CLAUDE_SETTINGS_PATH);
-    log("debug", `mergeSettings file size=${info.size} mtime=${new Date(info.mtimeMs).toISOString()}`);
+    log("debug", `mergeSettings file`, {
+      size: info.size,
+      mtime: new Date(info.mtimeMs).toISOString()
+    });
   } catch (error) {
-    log("debug", `mergeSettings stat failed: ${error instanceof Error ? error.message : String(error)}`);
+    log("debug", `mergeSettings stat failed`, {
+      error: error instanceof Error ? error.message : String(error)
+    });
   }
 };
 var findSessionFile = async (sessionId) => {
@@ -236,10 +304,103 @@ var findSessionFile = async (sessionId) => {
   await walk(CLAUDE_PROJECTS_DIR);
   return bestPath;
 };
-var appendDebugLog = async (message) => {
-  const logFile = Bun.file(DEBUG_LOG_PATH);
-  const content = await logFile.text();
-  await Bun.write(DEBUG_LOG_PATH, content + message, { createPath: true });
+var isDirectory = async (path) => {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+};
+var resolveSessionDir = async (sessionFile) => {
+  if (!sessionFile.endsWith(".jsonl")) {
+    return null;
+  }
+  const candidate = sessionFile.slice(0, -".jsonl".length);
+  return await isDirectory(candidate) ? candidate : null;
+};
+var findSessionDir = async (sessionId) => {
+  let bestPath = null;
+  let bestMtimeMs = 0;
+  const walk = async (dir) => {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      if (entry.name === sessionId) {
+        const info = await stat(fullPath);
+        if (!bestPath || info.mtimeMs > bestMtimeMs) {
+          bestPath = fullPath;
+          bestMtimeMs = info.mtimeMs;
+        }
+      }
+      await walk(fullPath);
+    }
+  };
+  await walk(CLAUDE_PROJECTS_DIR);
+  return bestPath;
+};
+var normalizePath = (value) => value.split(sep).join("/");
+var collectSessionStateFiles = async (sessionDir) => {
+  const files = [];
+  const walk = async (dir) => {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const info = await stat(fullPath);
+      files.push({
+        fullPath,
+        relativePath: normalizePath(relative(sessionDir, fullPath)),
+        size: info.size,
+        mtimeMs: info.mtimeMs
+      });
+    }
+  };
+  await walk(sessionDir);
+  return files;
+};
+var buildStateChunks = async (sessionDir) => {
+  const files = await collectSessionStateFiles(sessionDir);
+  const chunks = [];
+  for (const file of files) {
+    const data = new Uint8Array(await Bun.file(file.fullPath).arrayBuffer());
+    const fileHash = createHash("sha256").update(data).digest("hex");
+    const encoded = Buffer.from(data).toString("base64");
+    const partCount = Math.max(1, Math.ceil(encoded.length / MAX_STATE_CHUNK_SIZE));
+    for (let partIndex = 0;partIndex < partCount; partIndex += 1) {
+      const start = partIndex * MAX_STATE_CHUNK_SIZE;
+      const end = start + MAX_STATE_CHUNK_SIZE;
+      chunks.push({
+        path: file.relativePath,
+        content: encoded.slice(start, end),
+        encoding: "base64",
+        fileHash,
+        partIndex,
+        partCount,
+        size: file.size,
+        mtimeMs: file.mtimeMs
+      });
+    }
+  }
+  return chunks;
 };
 var buildLogLines = (raw) => {
   const lines = raw.split(`
@@ -282,49 +443,154 @@ var uploadLogs = async (siteUrl, token, sessionId, raw) => {
     }
   }
 };
+var uploadStateFiles = async (siteUrl, token, sessionId, chunks) => {
+  for (let i = 0;i < chunks.length; i += MAX_STATE_CHUNKS_PER_BATCH) {
+    const batch = chunks.slice(i, i + MAX_STATE_CHUNKS_PER_BATCH);
+    const response = await fetch(`${siteUrl}/api/ingest/state`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+        ...process.env.BISYNC_SESSION_ID ? { "X-Bisync-Session-Id": process.env.BISYNC_SESSION_ID } : {}
+      },
+      body: JSON.stringify({
+        session_id: sessionId,
+        files: batch
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const error = new Error(`State ingestion failed: ${response.status} ${errorText}`);
+      error.status = response.status;
+      throw error;
+    }
+  }
+};
+var signOutRemote = async (siteUrl, token) => {
+  try {
+    const response = await fetch(`${siteUrl}/api/auth/sign-out`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify({})
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      return {
+        ok: false,
+        error: `${response.status} ${errorText}`.trim()
+      };
+    }
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+};
 var runSetup = async (args) => {
   log("debug", `runSetup start`);
-  const force = args.includes("--force");
-  log("debug", `runSetup force=${force}`);
+  const force = Boolean(args.force);
+  log("debug", "runSetup", { force });
   const configExists = await Bun.file(CONFIG_PATH).exists();
-  log("debug", `config path=${CONFIG_PATH} exists=${configExists}`);
+  log("debug", "config", { path: CONFIG_PATH, exists: configExists });
   let existingConfig = null;
   if (configExists) {
     try {
       existingConfig = await readConfig();
-      log("debug", `config loaded siteUrl=${existingConfig.siteUrl} token=${existingConfig.token ? "present" : "missing"}`);
+      log("debug", "config loaded", {
+        siteUrl: existingConfig.siteUrl,
+        token: existingConfig.token ? "present" : "missing"
+      });
     } catch {
       log("debug", `config load failed; continuing without existing config`);
       existingConfig = null;
     }
   }
   const resolution = resolveSiteUrl(args);
-  log("debug", `siteUrl resolved=${resolution.siteUrl ?? "null"} source=${resolution.source}`);
+  log("debug", "siteUrl resolved", {
+    siteUrl: resolution.siteUrl ?? "null",
+    source: resolution.source
+  });
   const siteUrl = resolution.siteUrl ?? existingConfig?.siteUrl ?? null;
   if (!resolution.siteUrl && existingConfig?.siteUrl) {
-    log("debug", `siteUrl fallback to existing config ${existingConfig.siteUrl}`);
+    log("debug", "siteUrl fallback to existing config", { siteUrl: existingConfig.siteUrl });
   }
   if (!siteUrl) {
-    log("debug", `runSetup aborted: missing siteUrl`);
+    log("debug", "runSetup aborted", { error: "missing-site-url" });
     throw new Error("Missing site URL. Provide --site-url or BISYNC_SITE_URL.");
   }
   if (configExists && existingConfig?.token && !force) {
-    log("debug", `using existing token; updating Claude settings only`);
+    log("debug", "using existing token; updating Claude settings only");
     await mergeSettings();
-    log("info", `Updated Claude settings using existing credentials at ${CONFIG_PATH}`);
+    log("info", "Updated Claude settings using existing credentials", { path: CONFIG_PATH });
     return;
   }
   const token = await deviceAuthFlow(siteUrl);
   await writeConfig({ siteUrl, token, clientId: CLIENT_ID });
-  log("debug", `config written to ${CONFIG_PATH}`);
+  log("debug", "config written", { path: CONFIG_PATH });
   await mergeSettings();
-  log("info", `Configured Claude settings and saved credentials to ${CONFIG_PATH}`);
+  log("info", "Configured Claude settings and saved credentials", { path: CONFIG_PATH });
 };
-var runVerify = async () => {
-  log("debug", `runVerify start config=${CONFIG_PATH}`);
+var runAuthLogin = async (args) => {
+  log("debug", "runAuthLogin start");
+  const force = Boolean(args.force);
+  const config = await readConfigIfExists();
+  const resolution = resolveSiteUrl(args);
+  const siteUrl = resolution.siteUrl ?? config?.siteUrl ?? null;
+  if (!siteUrl) {
+    log("error", "runAuthLogin aborted", { error: "missing-site-url" });
+    throw new Error("Missing site URL. Provide --site-url or BISYNC_SITE_URL.");
+  }
+  if (config?.token) {
+    const shouldReauth = force || await promptYesNo("Already signed in. Sign out and re-authenticate?", false);
+    if (!shouldReauth) {
+      log("info", "Keeping existing credentials.");
+      return;
+    }
+    const signOutResult = await signOutRemote(siteUrl, config.token);
+    await writeConfig({ siteUrl, token: "", clientId: CLIENT_ID });
+    if (!signOutResult.ok) {
+      log("warn", `Remote sign-out failed: ${signOutResult.error ?? "unknown error"}. Continuing with login.`);
+    }
+  }
+  const token = await deviceAuthFlow(siteUrl);
+  await writeConfig({ siteUrl, token, clientId: CLIENT_ID });
+  log("info", `Signed in and saved credentials to ${CONFIG_PATH}`);
+};
+var runAuthLogout = async (args) => {
+  log("debug", `runAuthLogout start`);
+  const config = await readConfigIfExists();
+  const resolution = resolveSiteUrl(args);
+  const siteUrl = resolution.siteUrl ?? config?.siteUrl ?? null;
+  if (!siteUrl) {
+    if (!config?.token) {
+      log("info", "Already signed out.");
+      return;
+    }
+    throw new Error("Missing site URL. Provide --site-url or BISYNC_SITE_URL.");
+  }
+  if (!config?.token) {
+    await writeConfig({ siteUrl, token: "", clientId: CLIENT_ID });
+    log("info", "Already signed out.");
+    return;
+  }
+  const signOutResult = await signOutRemote(siteUrl, config.token);
+  await writeConfig({ siteUrl, token: "", clientId: CLIENT_ID });
+  if (!signOutResult.ok) {
+    log("warn", `Remote sign-out failed: ${signOutResult.error ?? "unknown error"}. Local credentials cleared.`);
+    return;
+  }
+  log("info", "Signed out.");
+};
+var runSessionList = async () => {
+  log("debug", `runSessionList start`, { config: CONFIG_PATH });
   const config = await readConfig();
   const siteUrl = process.env.BISYNC_SITE_URL ?? config.siteUrl;
-  log("debug", `runVerify siteUrl=${siteUrl}`);
+  log("debug", `runSessionList`, { siteUrl });
   const response = await fetch(`${siteUrl}/api/list-sessions`, {
     method: "GET",
     headers: {
@@ -333,20 +599,21 @@ var runVerify = async () => {
   });
   if (!response.ok) {
     const errorText = await response.text();
-    log("debug", `runVerify failed status=${response.status}`);
-    throw new Error(`Verify failed: ${response.status} ${errorText}`);
+    log("debug", `runSessionList failed`, { status: response.status });
+    throw new Error(`Session list failed: ${response.status} ${errorText}`);
   }
+  log("debug", "runSessionList ok", { status: response.status });
   const data = await response.json();
   if (data.sessions.length === 0) {
     log("info", "No sessions found.");
     return;
   }
   for (const session of data.sessions) {
-    log("info", session.externalId);
+    console.log(session.externalId);
   }
 };
 var runHook = async (hookName) => {
-  log("debug", `runHook start hook=${hookName}`);
+  log("debug", `runHook start`, { hook: hookName });
   const stdinRaw = await new Promise((resolve2, reject) => {
     let data = "";
     process.stdin.setEncoding("utf8");
@@ -356,24 +623,19 @@ var runHook = async (hookName) => {
     process.stdin.on("end", () => resolve2(data));
     process.stdin.on("error", (error) => reject(error));
   });
-  await appendDebugLog(`[${new Date().toISOString()}] hook=${hookName} stdin=${stdinRaw.trim()}
-`);
-  if (!stdinRaw.trim()) {
-    await appendDebugLog(`[${new Date().toISOString()}] hook=${hookName} error=empty-stdin
-`);
+  log("debug", `runHook`, { hook: hookName, stdin: stdinRaw.trim() });
+  if (!stdinRaw.trim())
     return;
-  }
   const stdinPayload = JSON.parse(stdinRaw);
   const sessionId = stdinPayload.session_id;
   if (!sessionId) {
-    await appendDebugLog(`[${new Date().toISOString()}] hook=${hookName} error=missing-session-id
-`);
+    log("debug", `runHook`, { hook: hookName, error: "missing-session-id" });
     return;
   }
   const config = await readConfig();
   const siteUrl = process.env.BISYNC_SITE_URL ?? config.siteUrl;
   const token = config.token;
-  log("debug", `runHook siteUrl=${siteUrl}`);
+  log("debug", `runHook`, { siteUrl });
   let sessionFile = null;
   if (typeof stdinPayload.transcript_path === "string") {
     const resolvedPath = resolve(stdinPayload.transcript_path);
@@ -385,57 +647,102 @@ var runHook = async (hookName) => {
     sessionFile = await findSessionFile(sessionId);
   }
   if (!sessionFile) {
-    log("debug", `runHook session file missing sessionId=${sessionId}`);
-    await appendDebugLog(`[${new Date().toISOString()}] hook=${hookName} error=session-file-not-found session_id=${sessionId}
-`);
-    return;
+    log("debug", `runHook`, { sessionId, error: "session-file-not-found" });
   }
-  log("debug", `runHook sessionFile=${sessionFile}`);
-  const raw = await Bun.file(sessionFile).text();
-  if (!raw.trim()) {
-    log("debug", `runHook session file empty sessionId=${sessionId}`);
-    await appendDebugLog(`[${new Date().toISOString()}] hook=${hookName} error=empty-log session_id=${sessionId}
-`);
+  let sessionDir = null;
+  if (sessionFile) {
+    sessionDir = await resolveSessionDir(sessionFile);
+  }
+  if (!sessionDir) {
+    sessionDir = await findSessionDir(sessionId);
+  }
+  if (!sessionFile && !sessionDir) {
     return;
   }
-  try {
-    await uploadLogs(siteUrl, token, sessionId, raw);
-    log("debug", `runHook upload ok sessionId=${sessionId}`);
-  } catch (error) {
-    log("debug", `runHook upload failed sessionId=${sessionId} message=${error instanceof Error ? error.message : String(error)}`);
-    await appendDebugLog(`[${new Date().toISOString()}] hook=${hookName} error=upload-failed session_id=${sessionId} message=${error instanceof Error ? error.message : String(error)}
-`);
+  if (sessionFile) {
+    log("debug", `runHook`, { sessionFile });
+    const raw = await Bun.file(sessionFile).text();
+    if (!raw.trim()) {
+      log("debug", `runHook`, { sessionId, error: "empty-log" });
+    } else {
+      try {
+        await uploadLogs(siteUrl, token, sessionId, raw);
+        log("debug", `runHook`, { sessionId, error: "upload-ok" });
+      } catch (error) {
+        log("debug", `runHook`, {
+          sessionId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  if (sessionDir) {
+    log("debug", `runHook`, { sessionDir });
+    try {
+      const stateChunks = await buildStateChunks(sessionDir);
+      if (stateChunks.length === 0) {
+        log("debug", `runHook`, { sessionId, error: "no-state-files" });
+        return;
+      }
+      await uploadStateFiles(siteUrl, token, sessionId, stateChunks);
+      log("debug", `runHook`, { sessionId, error: "state-upload-ok" });
+    } catch (error) {
+      log("debug", `runHook`, {
+        sessionId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
   }
 };
 var main = async () => {
-  if (process.argv.includes("--version")) {
+  const { values, positionals } = parseArgs();
+  if (values.help) {
+    printUsage();
+    process.exit(0);
+  }
+  if (values.version) {
     console.log(`\u25B6\uFE0E ${version} (Bun ${Bun.version})`);
     process.exit(0);
   }
-  if (process.argv.includes("--verbose")) {
+  if (values.verbose) {
     LOG_LEVEL = "debug";
   }
-  const rawArgs = process.argv.slice(2);
-  const [command, ...args] = rawArgs;
-  log("debug", `argv=${JSON.stringify(rawArgs)}`);
+  const [command, subcommand] = positionals;
+  log("debug", "argv", { argv: JSON.stringify(process.argv.slice(2)) });
   if (!command) {
-    usage();
+    printUsage();
     process.exit(1);
   }
   try {
     if (command === "setup") {
-      await runSetup(args);
-      return;
+      await runSetup(values);
+      process.exit(0);
     }
-    if (command === "verify") {
-      await runVerify();
-      return;
+    if (command === "auth") {
+      if (subcommand === "login") {
+        await runAuthLogin(values);
+        process.exit(0);
+      }
+      if (subcommand === "logout") {
+        await runAuthLogout(values);
+        process.exit(0);
+      }
+      printUsage();
+      process.exit(1);
+    }
+    if (command === "session") {
+      if (subcommand === "list") {
+        await runSessionList();
+        process.exit(0);
+      }
+      printUsage();
+      process.exit(1);
     }
     if (command === "hook") {
-      await runHook(args[0] ?? "unknown");
-      return;
+      await runHook(subcommand ?? "unknown");
+      process.exit(0);
     }
-    usage();
+    printUsage();
     process.exit(1);
   } catch (error) {
     log("error", error instanceof Error ? error.message : String(error));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bisync-cli",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "bin": {
     "bisync": "dist/bisync.js"
   },