bisync-cli 0.0.1

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "bisync-cli",
+  "version": "0.0.1",
+  "bin": {
+    "bisync": "dist/bisync"
+  },
+  "type": "module",
+  "scripts": {
+    "dev": "bun run dev",
+    "build": "bun build src/bin.ts --compile --bytecode --minify --outfile dist/bisync"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.5"
+  }
+}

package/src/bin.ts

@@ -0,0 +1,445 @@
+#!/usr/bin/env bun
+/// <reference types="bun" />
+
+import type { Dirent } from "node:fs";
+
+import { readdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+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 CLIENT_ID = "bisync-cli";
+const MAX_LINES_PER_BATCH = 200;
+
+type Config = {
+  siteUrl: string;
+  token: string;
+  clientId: string;
+};
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const 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)
+`);
+};
+
+const readConfig = async (): Promise<Config> => {
+  return await Bun.file(CONFIG_PATH).json();
+};
+
+const writeConfig = async (config: Config) => {
+  await Bun.write(CONFIG_PATH, JSON.stringify(config, null, 2), {
+    createPath: true,
+  });
+};
+
+const resolveSiteUrl = (args: string[]) => {
+  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;
+};
+
+const openBrowser = async (url: string) => {
+  if (process.platform !== "darwin") {
+    return;
+  }
+  try {
+    await Bun.$`open ${url}`;
+  } catch {
+    // Ignore failures to open browser.
+  }
+};
+
+const deviceAuthFlow = async (siteUrl: string) => {
+  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: {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete?: string;
+    interval?: number;
+  } = 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: {
+      access_token: string;
+      error?: string;
+      error_description?: string;
+    } = 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(),
+    );
+  }
+};
+
+type ClaudeHookEntry = {
+  matcher?: string;
+  hooks: Array<{
+    type: "command";
+    command: string;
+  }>;
+};
+
+type ClaudeSettings = {
+  enabledPlugins?: Record<string, boolean>;
+  hooks?: Record<string, ClaudeHookEntry[]>;
+};
+
+const ensureHookEntry = (entries: ClaudeHookEntry[], next: ClaudeHookEntry) => {
+  const sameMatcher = (entry: ClaudeHookEntry) =>
+    (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;
+};
+
+const mergeSettings = async () => {
+  const current: ClaudeSettings = await Bun.file(CLAUDE_SETTINGS_PATH)
+    .json()
+    .catch(() => ({}));
+
+  const hooks = current.hooks ?? {};
+  const definitions: Array<{ name: string; matcher?: string }> = [
+    { 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: ClaudeSettings = {
+    ...current,
+    enabledPlugins: current.enabledPlugins ?? {},
+    hooks,
+  };
+  await Bun.write(CLAUDE_SETTINGS_PATH, JSON.stringify(nextConfig, null, 2), {
+    createPath: true,
+  });
+};
+
+const findSessionFile = async (sessionId: string) => {
+  let bestPath: string | null = null;
+  let bestMtimeMs = 0;
+  const targetName = `${sessionId}.jsonl`;
+
+  const walk = async (dir: string) => {
+    let entries: Dirent[];
+    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;
+};
+
+const appendDebugLog = async (message: string) => {
+  const logFile = Bun.file(DEBUG_LOG_PATH);
+  const content = await logFile.text();
+  await logFile.write(content + message);
+};
+
+const buildLogLines = (raw: string) => {
+  const lines = raw.split("\n").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) as { ts?: number; timestamp?: number };
+      if (typeof parsed.ts === "number") {
+        ts = parsed.ts;
+      } else if (typeof parsed.timestamp === "number") {
+        ts = parsed.timestamp;
+      }
+    } catch {
+      // Ignore JSON parse errors; fall back to base timestamp.
+    }
+    return { ts, log: line, encoding: "utf8" as const };
+  });
+};
+
+const uploadLogs = async (siteUrl: string, token: string, sessionId: string, raw: string) => {
+  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 as Error & { status?: number }).status = response.status;
+      throw error;
+    }
+  }
+};
+
+const runSetup = async (args: string[]) => {
+  const force = args.includes("--force");
+  const configExists = await Bun.file(CONFIG_PATH).exists();
+  let existingConfig: Config | null = 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}`);
+};
+
+const 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()) as {
+    sessions: { externalId: string }[];
+  };
+
+  if (data.sessions.length === 0) {
+    console.log("No sessions found.");
+    return;
+  }
+
+  for (const session of data.sessions) {
+    console.log(session.externalId);
+  }
+};
+
+const runHook = async (hookName: string) => {
+  const stdinRaw = await new Promise<string>((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", (error) => reject(error));
+  });
+
+  await appendDebugLog(`[${new Date().toISOString()}] hook=${hookName} stdin=${stdinRaw.trim()}\n`);
+
+  if (!stdinRaw.trim()) {
+    await appendDebugLog(`[${new Date().toISOString()}] hook=${hookName} error=empty-stdin\n`);
+    return;
+  }
+
+  const stdinPayload = JSON.parse(stdinRaw) as {
+    session_id?: string;
+    transcript_path?: string;
+  };
+  const sessionId = stdinPayload.session_id;
+  if (!sessionId) {
+    await appendDebugLog(
+      `[${new Date().toISOString()}] hook=${hookName} error=missing-session-id\n`,
+    );
+    return;
+  }
+
+  const config = await readConfig();
+  const siteUrl = process.env.BISYNC_SITE_URL ?? config.siteUrl;
+  const token = config.token;
+
+  let sessionFile: string | null = 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}\n`,
+    );
+    return;
+  }
+
+  const raw = await Bun.file(sessionFile).text();
+  if (!raw.trim()) {
+    await appendDebugLog(
+      `[${new Date().toISOString()}] hook=${hookName} error=empty-log session_id=${sessionId}\n`,
+    );
+    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)}\n`,
+    );
+  }
+};
+
+const main = async () => {
+  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);
+  }
+};
+
+main();