bisync-cli 0.0.2 → 0.0.4

package/dist/bisync.js

@@ -0,0 +1,426 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/bin.ts
+import { readdir, stat } from "fs/promises";
+import { homedir } from "os";
+import { join, resolve } from "path";
+// package.json
+var version = "0.0.3";
+
+// src/bin.ts
+var CONFIG_DIR = join(homedir(), ".agent-bisync");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+var CLAUDE_SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+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 = () => {
+  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)
+
+Global options:
+  --verbose                Enable verbose logging
+`);
+};
+var LOG_LEVEL = "info";
+var log = (level, message) => {
+  if (level < LOG_LEVEL) {
+    return;
+  }
+  const logMessage = `[bisync][${level}] ${message}`;
+  console.log(logMessage);
+};
+var readConfig = async () => {
+  return await Bun.file(CONFIG_PATH).json();
+};
+var writeConfig = async (config) => {
+  await Bun.write(CONFIG_PATH, JSON.stringify(config, null, 2), {
+    createPath: true
+  });
+};
+var resolveSiteUrl = (args) => {
+  const argIndex = args.findIndex((value) => value === "--site-url" || value === "--siteUrl");
+  const argValue = argIndex >= 0 ? args[argIndex + 1] : undefined;
+  const envValue = process.env.BISYNC_SITE_URL;
+  if (argValue) {
+    return { siteUrl: argValue, source: "arg" };
+  }
+  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) => {
+  if (process.platform !== "darwin") {
+    return;
+  }
+  try {
+    await Bun.$`open ${url}`;
+  } catch {}
+};
+var deviceAuthFlow = async (siteUrl) => {
+  log("debug", `device auth start siteUrl=${siteUrl}`);
+  const codeResponse = await fetch(`${siteUrl}/api/auth/device/code`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ client_id: CLIENT_ID })
+  });
+  if (!codeResponse.ok) {
+    const errorText = await codeResponse.text();
+    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}`);
+  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}`);
+  await openBrowser(verificationUrl);
+  const intervalMs = Math.max(1, codeData.interval ?? 5) * 1000;
+  log("debug", `device auth polling intervalMs=${intervalMs}`);
+  let pollDelay = intervalMs;
+  while (true) {
+    await sleep(pollDelay);
+    const tokenResponse = await fetch(`${siteUrl}/api/auth/device/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: codeData.device_code,
+        client_id: CLIENT_ID
+      })
+    });
+    const tokenData = await tokenResponse.json();
+    if (tokenResponse.ok && tokenData.access_token) {
+      log("debug", `device auth success status=${tokenResponse.status}`);
+      return tokenData.access_token;
+    }
+    if (tokenData.error === "authorization_pending") {
+      continue;
+    }
+    if (tokenData.error === "slow_down") {
+      pollDelay += 1000;
+      log("debug", `device auth slow_down nextDelayMs=${pollDelay}`);
+      continue;
+    }
+    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());
+  }
+};
+var ensureHookEntry = (entries, next) => {
+  const sameMatcher = (entry) => (entry.matcher ?? null) === (next.matcher ?? null);
+  const command = next.hooks[0]?.command;
+  if (!command) {
+    return entries;
+  }
+  const existing = entries.find(sameMatcher);
+  if (!existing) {
+    entries.push(next);
+    return entries;
+  }
+  if (!existing.hooks.some((hook) => hook.command === command)) {
+    existing.hooks.push({ type: "command", command });
+  }
+  return entries;
+};
+var mergeSettings = async () => {
+  log("debug", `mergeSettings path=${CLAUDE_SETTINGS_PATH}`);
+  const settingsFile = Bun.file(CLAUDE_SETTINGS_PATH);
+  const settingsExists = await settingsFile.exists();
+  log("debug", `mergeSettings existing=${settingsExists}`);
+  let current = {};
+  if (settingsExists) {
+    try {
+      current = await settingsFile.json();
+      log("debug", `mergeSettings read ok`);
+    } catch (error) {
+      log("debug", `mergeSettings read failed: ${error instanceof Error ? error.message : String(error)}`);
+      current = {};
+    }
+  }
+  const hooks = current.hooks ?? {};
+  const definitions = [
+    { name: "SessionStart" },
+    { name: "SessionEnd" },
+    { name: "UserPromptSubmit" },
+    { name: "PostToolUse", matcher: "*" },
+    { name: "Stop", matcher: "*" }
+  ];
+  for (const definition of definitions) {
+    const command = `bisync hook ${definition.name}`;
+    const entries = hooks[definition.name] ?? [];
+    ensureHookEntry(entries, {
+      matcher: definition.matcher,
+      hooks: [{ type: "command", command }]
+    });
+    hooks[definition.name] = entries;
+  }
+  const nextConfig = {
+    ...current,
+    enabledPlugins: current.enabledPlugins ?? {},
+    hooks
+  };
+  await Bun.write(CLAUDE_SETTINGS_PATH, JSON.stringify(nextConfig, null, 2), {
+    createPath: true
+  });
+  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()}`);
+  } catch (error) {
+    log("debug", `mergeSettings stat failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+};
+var findSessionFile = async (sessionId) => {
+  let bestPath = null;
+  let bestMtimeMs = 0;
+  const targetName = `${sessionId}.jsonl`;
+  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() || entry.name !== targetName) {
+        continue;
+      }
+      const info = await stat(fullPath);
+      if (!bestPath || info.mtimeMs > bestMtimeMs) {
+        bestPath = fullPath;
+        bestMtimeMs = info.mtimeMs;
+      }
+    }
+  };
+  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 buildLogLines = (raw) => {
+  const lines = raw.split(`
+`).filter((line) => line.trim().length > 0);
+  const baseNow = Date.now();
+  return lines.map((line, index) => {
+    let ts = baseNow + index;
+    try {
+      const parsed = JSON.parse(line);
+      if (typeof parsed.ts === "number") {
+        ts = parsed.ts;
+      } else if (typeof parsed.timestamp === "number") {
+        ts = parsed.timestamp;
+      }
+    } catch {}
+    return { ts, log: line, encoding: "utf8" };
+  });
+};
+var uploadLogs = async (siteUrl, token, sessionId, raw) => {
+  const lines = buildLogLines(raw);
+  for (let i = 0;i < lines.length; i += MAX_LINES_PER_BATCH) {
+    const batch = lines.slice(i, i + MAX_LINES_PER_BATCH);
+    const response = await fetch(`${siteUrl}/api/ingest/logs`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify({
+        session_id: sessionId,
+        lines: batch
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const error = new Error(`Log ingestion failed: ${response.status} ${errorText}`);
+      error.status = response.status;
+      throw error;
+    }
+  }
+};
+var runSetup = async (args) => {
+  log("debug", `runSetup start`);
+  const force = args.includes("--force");
+  log("debug", `runSetup force=${force}`);
+  const configExists = await Bun.file(CONFIG_PATH).exists();
+  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"}`);
+    } 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}`);
+  const siteUrl = resolution.siteUrl ?? existingConfig?.siteUrl ?? null;
+  if (!resolution.siteUrl && existingConfig?.siteUrl) {
+    log("debug", `siteUrl fallback to existing config ${existingConfig.siteUrl}`);
+  }
+  if (!siteUrl) {
+    log("debug", `runSetup aborted: missing siteUrl`);
+    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`);
+    await mergeSettings();
+    log("info", `Updated Claude settings using existing credentials at ${CONFIG_PATH}`);
+    return;
+  }
+  const token = await deviceAuthFlow(siteUrl);
+  await writeConfig({ siteUrl, token, clientId: CLIENT_ID });
+  log("debug", `config written to ${CONFIG_PATH}`);
+  await mergeSettings();
+  log("info", `Configured Claude settings and saved credentials to ${CONFIG_PATH}`);
+};
+var runVerify = async () => {
+  log("debug", `runVerify start config=${CONFIG_PATH}`);
+  const config = await readConfig();
+  const siteUrl = process.env.BISYNC_SITE_URL ?? config.siteUrl;
+  log("debug", `runVerify siteUrl=${siteUrl}`);
+  const response = await fetch(`${siteUrl}/api/list-sessions`, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${config.token}`
+    }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    log("debug", `runVerify failed status=${response.status}`);
+    throw new Error(`Verify failed: ${response.status} ${errorText}`);
+  }
+  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);
+  }
+};
+var runHook = async (hookName) => {
+  log("debug", `runHook start hook=${hookName}`);
+  const stdinRaw = await new Promise((resolve2, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    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
+`);
+    return;
+  }
+  const stdinPayload = JSON.parse(stdinRaw);
+  const sessionId = stdinPayload.session_id;
+  if (!sessionId) {
+    await appendDebugLog(`[${new Date().toISOString()}] 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}`);
+  let sessionFile = null;
+  if (typeof stdinPayload.transcript_path === "string") {
+    const resolvedPath = resolve(stdinPayload.transcript_path);
+    if (await Bun.file(resolvedPath).exists()) {
+      sessionFile = resolvedPath;
+    }
+  }
+  if (!sessionFile) {
+    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 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}
+`);
+    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)}
+`);
+  }
+};
+var main = async () => {
+  if (process.argv.includes("--version")) {
+    console.log(`\u25B6\uFE0E ${version} (Bun ${Bun.version})`);
+    process.exit(0);
+  }
+  if (process.argv.includes("--verbose")) {
+    LOG_LEVEL = "debug";
+  }
+  const rawArgs = process.argv.slice(2);
+  const [command, ...args] = rawArgs;
+  log("debug", `argv=${JSON.stringify(rawArgs)}`);
+  if (!command) {
+    usage();
+    process.exit(1);
+  }
+  try {
+    if (command === "setup") {
+      await runSetup(args);
+      return;
+    }
+    if (command === "verify") {
+      await runVerify();
+      return;
+    }
+    if (command === "hook") {
+      await runHook(args[0] ?? "unknown");
+      return;
+    }
+    usage();
+    process.exit(1);
+  } catch (error) {
+    log("error", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+};
+await main();

package/package.json

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

package/src/bin.ts

@@ -7,12 +7,13 @@ import { readdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 
+import { version } from "../package.json" with { type: "json" };
+
 const CONFIG_DIR = join(homedir(), ".agent-bisync");
 const CONFIG_PATH = join(CONFIG_DIR, "config.json");
 const CLAUDE_SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
 const CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
-const DEBUG_DIR = join(homedir(), ".bysync");
-const DEBUG_LOG_PATH = join(DEBUG_DIR, "debug.log");
+const DEBUG_LOG_PATH = join(CONFIG_DIR, "debug.log");
 const CLIENT_ID = "bisync-cli";
 const MAX_LINES_PER_BATCH = 200;
 
@@ -22,6 +23,11 @@ type Config = {
   clientId: string;
 };
 
+type SiteUrlResolution = {
+  siteUrl: string | null;
+  source: "arg" | "env" | "vite" | "missing";
+};
+
 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
 const usage = () => {
@@ -31,9 +37,21 @@ Commands:
   setup --site-url <url>   Configure hooks and authenticate
   verify                   Check auth and list session ids
   hook <HOOK>              Handle Claude hook input (stdin JSON)
+
+Global options:
+  --verbose                Enable verbose logging
 `);
 };
 
+let LOG_LEVEL = "info";
+const log = (level: "debug" | "info" | "warn" | "error", message: string) => {
+  if (level < LOG_LEVEL) {
+    return;
+  }
+  const logMessage = `[bisync][${level}] ${message}`;
+  console.log(logMessage);
+};
+
 const readConfig = async (): Promise<Config> => {
   return await Bun.file(CONFIG_PATH).json();
 };
@@ -44,21 +62,27 @@ const writeConfig = async (config: Config) => {
   });
 };
 
-const resolveSiteUrl = (args: string[]) => {
+const resolveSiteUrl = (args: string[]): SiteUrlResolution => {
   const argIndex = args.findIndex((value) => value === "--site-url" || value === "--siteUrl");
   const argValue = argIndex >= 0 ? args[argIndex + 1] : undefined;
   const envValue = process.env.BISYNC_SITE_URL;
   if (argValue) {
-    return argValue;
+    return { siteUrl: argValue, source: "arg" };
   }
   if (envValue) {
-    return envValue;
+    return { siteUrl: envValue, source: "env" };
   }
   const viteConvexUrl = process.env.VITE_CONVEX_URL;
   if (viteConvexUrl?.endsWith(".convex.cloud")) {
-    return viteConvexUrl.replace(".convex.cloud", ".convex.site");
+    return {
+      siteUrl: viteConvexUrl.replace(".convex.cloud", ".convex.site"),
+      source: "vite",
+    };
+  }
+  if (viteConvexUrl) {
+    return { siteUrl: viteConvexUrl, source: "vite" };
   }
-  return viteConvexUrl ?? null;
+  return { siteUrl: null, source: "missing" };
 };
 
 const openBrowser = async (url: string) => {
@@ -73,6 +97,7 @@ const openBrowser = async (url: string) => {
 };
 
 const deviceAuthFlow = async (siteUrl: string) => {
+  log("debug", `device auth start siteUrl=${siteUrl}`);
   const codeResponse = await fetch(`${siteUrl}/api/auth/device/code`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -81,9 +106,12 @@ const deviceAuthFlow = async (siteUrl: string) => {
 
   if (!codeResponse.ok) {
     const errorText = await codeResponse.text();
+    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}`);
+
   const codeData: {
     device_code: string;
     user_code: string;
@@ -93,11 +121,12 @@ const deviceAuthFlow = async (siteUrl: string) => {
   } = await codeResponse.json();
 
   const verificationUrl = codeData.verification_uri_complete ?? codeData.verification_uri;
-  console.log(`Authorize this device: ${verificationUrl}`);
-  console.log(`User code: ${codeData.user_code}`);
+  log("info", `Authorize this device: ${verificationUrl}`);
+  log("info", `User code: ${codeData.user_code}`);
   await openBrowser(verificationUrl);
 
   const intervalMs = Math.max(1, codeData.interval ?? 5) * 1000;
+  log("debug", `device auth polling intervalMs=${intervalMs}`);
   let pollDelay = intervalMs;
 
   while (true) {
@@ -119,6 +148,7 @@ const deviceAuthFlow = async (siteUrl: string) => {
     } = await tokenResponse.json();
 
     if (tokenResponse.ok && tokenData.access_token) {
+      log("debug", `device auth success status=${tokenResponse.status}`);
       return tokenData.access_token;
     }
 
@@ -127,9 +157,14 @@ const deviceAuthFlow = async (siteUrl: string) => {
     }
     if (tokenData.error === "slow_down") {
       pollDelay += 1000;
+      log("debug", `device auth slow_down nextDelayMs=${pollDelay}`);
       continue;
     }
 
+    log(
+      "debug",
+      `device auth failed status=${tokenResponse.status} error=${tokenData.error ?? "unknown"}`,
+    );
     throw new Error(
       `Device auth failed: ${tokenData.error ?? "unknown"} ${
         tokenData.error_description ?? ""
@@ -170,9 +205,23 @@ const ensureHookEntry = (entries: ClaudeHookEntry[], next: ClaudeHookEntry) => {
 };
 
 const mergeSettings = async () => {
-  const current: ClaudeSettings = await Bun.file(CLAUDE_SETTINGS_PATH)
-    .json()
-    .catch(() => ({}));
+  log("debug", `mergeSettings path=${CLAUDE_SETTINGS_PATH}`);
+  const settingsFile = Bun.file(CLAUDE_SETTINGS_PATH);
+  const settingsExists = await settingsFile.exists();
+  log("debug", `mergeSettings existing=${settingsExists}`);
+  let current: ClaudeSettings = {};
+  if (settingsExists) {
+    try {
+      current = await settingsFile.json();
+      log("debug", `mergeSettings read ok`);
+    } catch (error) {
+      log(
+        "debug",
+        `mergeSettings read failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      current = {};
+    }
+  }
 
   const hooks = current.hooks ?? {};
   const definitions: Array<{ name: string; matcher?: string }> = [
@@ -201,6 +250,19 @@ const mergeSettings = async () => {
   await Bun.write(CLAUDE_SETTINGS_PATH, JSON.stringify(nextConfig, null, 2), {
     createPath: true,
   });
+  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()}`,
+    );
+  } catch (error) {
+    log(
+      "debug",
+      `mergeSettings stat failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
 };
 
 const findSessionFile = async (sessionId: string) => {
@@ -240,7 +302,7 @@ const findSessionFile = async (sessionId: string) => {
 const appendDebugLog = async (message: string) => {
   const logFile = Bun.file(DEBUG_LOG_PATH);
   const content = await logFile.text();
-  await logFile.write(content + message);
+  await Bun.write(DEBUG_LOG_PATH, content + message, { createPath: true });
 };
 
 const buildLogLines = (raw: string) => {
@@ -288,37 +350,55 @@ const uploadLogs = async (siteUrl: string, token: string, sessionId: string, raw
 };
 
 const runSetup = async (args: string[]) => {
+  log("debug", `runSetup start`);
   const force = args.includes("--force");
+  log("debug", `runSetup force=${force}`);
   const configExists = await Bun.file(CONFIG_PATH).exists();
+  log("debug", `config path=${CONFIG_PATH} exists=${configExists}`);
   let existingConfig: Config | null = null;
   if (configExists) {
     try {
       existingConfig = await readConfig();
+      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 siteUrl = resolveSiteUrl(args) ?? existingConfig?.siteUrl ?? null;
+  const resolution = resolveSiteUrl(args);
+  log("debug", `siteUrl resolved=${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}`);
+  }
   if (!siteUrl) {
+    log("debug", `runSetup aborted: missing siteUrl`);
     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`);
     await mergeSettings();
-    console.log(`Updated Claude settings using existing credentials at ${CONFIG_PATH}`);
+    log("info", `Updated Claude settings using existing credentials at ${CONFIG_PATH}`);
     return;
   }
 
   const token = await deviceAuthFlow(siteUrl);
   await writeConfig({ siteUrl, token, clientId: CLIENT_ID });
+  log("debug", `config written to ${CONFIG_PATH}`);
   await mergeSettings();
-  console.log(`Configured Claude settings and saved credentials to ${CONFIG_PATH}`);
+  log("info", `Configured Claude settings and saved credentials to ${CONFIG_PATH}`);
 };
 
 const runVerify = async () => {
+  log("debug", `runVerify start config=${CONFIG_PATH}`);
   const config = await readConfig();
   const siteUrl = process.env.BISYNC_SITE_URL ?? config.siteUrl;
+  log("debug", `runVerify siteUrl=${siteUrl}`);
   const response = await fetch(`${siteUrl}/api/list-sessions`, {
     method: "GET",
     headers: {
@@ -328,6 +408,7 @@ const 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}`);
   }
 
@@ -336,16 +417,17 @@ const runVerify = async () => {
   };
 
   if (data.sessions.length === 0) {
-    console.log("No sessions found.");
+    log("info", "No sessions found.");
     return;
   }
 
   for (const session of data.sessions) {
-    console.log(session.externalId);
+    log("info", session.externalId);
   }
 };
 
 const runHook = async (hookName: string) => {
+  log("debug", `runHook start hook=${hookName}`);
   const stdinRaw = await new Promise<string>((resolve, reject) => {
     let data = "";
     process.stdin.setEncoding("utf8");
@@ -378,6 +460,7 @@ const runHook = async (hookName: string) => {
   const config = await readConfig();
   const siteUrl = process.env.BISYNC_SITE_URL ?? config.siteUrl;
   const token = config.token;
+  log("debug", `runHook siteUrl=${siteUrl}`);
 
   let sessionFile: string | null = null;
   if (typeof stdinPayload.transcript_path === "string") {
@@ -390,14 +473,18 @@ const runHook = async (hookName: string) => {
     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}\n`,
     );
     return;
   }
 
+  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}\n`,
     );
@@ -406,7 +493,12 @@ const runHook = async (hookName: string) => {
 
   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)}\n`,
     );
@@ -414,7 +506,18 @@ const runHook = async (hookName: string) => {
 };
 
 const main = async () => {
-  const [command, ...args] = process.argv.slice(2);
+  if (process.argv.includes("--version")) {
+    console.log(`▶︎ ${version} (Bun ${Bun.version})`);
+    process.exit(0);
+  }
+
+  if (process.argv.includes("--verbose")) {
+    LOG_LEVEL = "debug";
+  }
+
+  const rawArgs = process.argv.slice(2);
+  const [command, ...args] = rawArgs;
+  log("debug", `argv=${JSON.stringify(rawArgs)}`);
   if (!command) {
     usage();
     process.exit(1);
@@ -437,9 +540,9 @@ const main = async () => {
     usage();
     process.exit(1);
   } catch (error) {
-    console.error(error instanceof Error ? error.message : error);
+    log("error", error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
 };
 
-void main();
+await main();