bisync-cli 0.0.2 → 0.0.3

package/dist/bisync.js

@@ -0,0 +1,355 @@
+#!/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_DIR = join(homedir(), ".bysync");
+var DEBUG_LOG_PATH = join(DEBUG_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)
+`);
+};
+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 argValue;
+  }
+  if (envValue) {
+    return envValue;
+  }
+  const viteConvexUrl = process.env.VITE_CONVEX_URL;
+  if (viteConvexUrl?.endsWith(".convex.cloud")) {
+    return viteConvexUrl.replace(".convex.cloud", ".convex.site");
+  }
+  return viteConvexUrl ?? null;
+};
+var openBrowser = async (url) => {
+  if (process.platform !== "darwin") {
+    return;
+  }
+  try {
+    await Bun.$`open ${url}`;
+  } catch {}
+};
+var deviceAuthFlow = async (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();
+    throw new Error(`Device code request failed: ${codeResponse.status} ${errorText}`);
+  }
+  const codeData = 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}`);
+  await openBrowser(verificationUrl);
+  const intervalMs = Math.max(1, codeData.interval ?? 5) * 1000;
+  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) {
+      return tokenData.access_token;
+    }
+    if (tokenData.error === "authorization_pending") {
+      continue;
+    }
+    if (tokenData.error === "slow_down") {
+      pollDelay += 1000;
+      continue;
+    }
+    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 () => {
+  const current = await Bun.file(CLAUDE_SETTINGS_PATH).json().catch(() => ({}));
+  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
+  });
+};
+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 logFile.write(content + message);
+};
+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) => {
+  const force = args.includes("--force");
+  const configExists = await Bun.file(CONFIG_PATH).exists();
+  let existingConfig = null;
+  if (configExists) {
+    try {
+      existingConfig = await readConfig();
+    } catch {
+      existingConfig = null;
+    }
+  }
+  const siteUrl = resolveSiteUrl(args) ?? existingConfig?.siteUrl ?? null;
+  if (!siteUrl) {
+    throw new Error("Missing site URL. Provide --site-url or BISYNC_SITE_URL.");
+  }
+  if (configExists && existingConfig?.token && !force) {
+    await mergeSettings();
+    console.log(`Updated Claude settings using existing credentials at ${CONFIG_PATH}`);
+    return;
+  }
+  const token = await deviceAuthFlow(siteUrl);
+  await writeConfig({ siteUrl, token, clientId: CLIENT_ID });
+  await mergeSettings();
+  console.log(`Configured Claude settings and saved credentials to ${CONFIG_PATH}`);
+};
+var runVerify = async () => {
+  const config = await readConfig();
+  const siteUrl = process.env.BISYNC_SITE_URL ?? config.siteUrl;
+  const response = await fetch(`${siteUrl}/api/list-sessions`, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${config.token}`
+    }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Verify failed: ${response.status} ${errorText}`);
+  }
+  const data = await response.json();
+  if (data.sessions.length === 0) {
+    console.log("No sessions found.");
+    return;
+  }
+  for (const session of data.sessions) {
+    console.log(session.externalId);
+  }
+};
+var runHook = async (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;
+  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) {
+    await appendDebugLog(`[${new Date().toISOString()}] hook=${hookName} error=session-file-not-found session_id=${sessionId}
+`);
+    return;
+  }
+  const raw = await Bun.file(sessionFile).text();
+  if (!raw.trim()) {
+    await appendDebugLog(`[${new Date().toISOString()}] hook=${hookName} error=empty-log session_id=${sessionId}
+`);
+    return;
+  }
+  try {
+    await uploadLogs(siteUrl, token, sessionId, raw);
+  } catch (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);
+  }
+  const [command, ...args] = process.argv.slice(2);
+  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) {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+};
+await main();

package/package.json

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

package/src/bin.ts

@@ -7,6 +7,8 @@ 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");
@@ -414,6 +416,11 @@ const runHook = async (hookName: string) => {
 };
 
 const main = async () => {
+  if (process.argv.includes("--version")) {
+    console.log(`▶︎ ${version} (Bun ${Bun.version})`);
+    process.exit(0);
+  }
+
   const [command, ...args] = process.argv.slice(2);
   if (!command) {
     usage();
@@ -442,4 +449,4 @@ const main = async () => {
   }
 };
 
-void main();
+await main();