bisync-cli 0.0.6 → 0.0.8

package/dist/bisync.js

@@ -7,7 +7,7 @@ import { readdir, stat } from "fs/promises";
 import { homedir } from "os";
 import { join, resolve } from "path";
 // package.json
-var version = "0.0.5";
+var version = "0.0.7";
 
 // src/bin.ts
 var CONFIG_DIR = join(homedir(), ".agent-bisync");
@@ -73,16 +73,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) => {

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "bisync-cli",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "bin": {
     "bisync": "dist/bisync.js"
   },
+  "files": [
+    "dist"
+  ],
   "type": "module",
   "scripts": {
-    "dev": "bun run dev",
     "build": "bun build src/bin.ts --outfile dist/bisync.js"
   },
   "devDependencies": {

package/src/bin.ts

@@ -1,571 +0,0 @@
-#!/usr/bin/env bun
-/// <reference types="bun" />
-
-import type { Dirent } from "node:fs";
-import type { WriteStream } from "node:fs";
-
-import { createWriteStream, mkdirSync } from "node:fs";
-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_LOG_PATH = join(CONFIG_DIR, "debug.log");
-const CLIENT_ID = "bisync-cli";
-const MAX_LINES_PER_BATCH = 200;
-
-type Config = {
-  siteUrl: string;
-  token: string;
-  clientId: string;
-};
-
-type SiteUrlResolution = {
-  siteUrl: string | null;
-  source: "arg" | "env" | "vite" | "missing";
-};
-
-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)
-
-Global options:
-  --verbose                Enable verbose logging
-`);
-};
-
-let LOG_LEVEL = "info";
-let debugLogStream: WriteStream | null = null;
-
-const getDebugLogStream = (): WriteStream | null => {
-  if (debugLogStream) return debugLogStream;
-  try {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-    debugLogStream = createWriteStream(DEBUG_LOG_PATH, { flags: "a" });
-    debugLogStream.on("error", () => {
-      // Silently discard write errors to avoid breaking the CLI.
-      debugLogStream = null;
-    });
-    return debugLogStream;
-  } catch {
-    return null;
-  }
-};
-
-const log = (level: "debug" | "info" | "warn" | "error", message: string) => {
-  const logMessage = `[bisync][${level}] ${message}`;
-  getDebugLogStream()?.write(`[${new Date().toISOString()}] ${logMessage}\n`);
-  if (level < LOG_LEVEL) {
-    return;
-  }
-  console.log(logMessage);
-};
-
-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[]): 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 { 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" };
-};
-
-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) => {
-  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: {
-    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;
-  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: {
-      access_token: string;
-      error?: string;
-      error_description?: string;
-    } = 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(),
-    );
-  }
-};
-
-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 () => {
-  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 }> = [
-    { 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,
-  });
-  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) => {
-  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 Bun.write(DEBUG_LOG_PATH, content + message, { createPath: true });
-};
-
-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}`,
-        ...(process.env.BISYNC_SESSION_ID
-          ? { "X-Bisync-Session-Id": process.env.BISYNC_SESSION_ID }
-          : {}),
-      },
-      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[]) => {
-  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 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}`);
-};
-
-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: {
-      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()) as {
-    sessions: { externalId: string }[];
-  };
-
-  if (data.sessions.length === 0) {
-    log("info", "No sessions found.");
-    return;
-  }
-
-  for (const session of data.sessions) {
-    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");
-    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;
-  log("debug", `runHook siteUrl=${siteUrl}`);
-
-  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) {
-    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`,
-    );
-    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)}\n`,
-    );
-  }
-};
-
-const main = async () => {
-  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);
-  }
-
-  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();