agentrace 0.0.1

package/dist/commands/init.d.ts

@@ -0,0 +1,5 @@
+export interface InitOptions {
+    url?: string;
+    dev?: boolean;
+}
+export declare function initCommand(options?: InitOptions): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,95 @@
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { saveConfig, getConfigPath } from "../config/manager.js";
+import { installHooks } from "../hooks/installer.js";
+import { startCallbackServer, getRandomPort, generateToken, } from "../utils/callback-server.js";
+import { openBrowser, buildSetupUrl } from "../utils/browser.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const CALLBACK_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+export async function initCommand(options = {}) {
+    // --url is required
+    if (!options.url) {
+        console.error("Error: --url option is required");
+        console.error("");
+        console.error("Usage: npx agentrace init --url <server-url>");
+        console.error("Example: npx agentrace init --url http://localhost:8080");
+        process.exit(1);
+    }
+    // Validate URL
+    let serverUrl;
+    try {
+        serverUrl = new URL(options.url);
+    }
+    catch {
+        console.error("Error: Invalid URL format");
+        process.exit(1);
+    }
+    console.log("Agentrace Setup\n");
+    if (options.dev) {
+        console.log("[Dev Mode] Using local CLI for hooks\n");
+    }
+    // Generate token and start callback server
+    const token = generateToken();
+    const port = getRandomPort();
+    const callbackUrl = `http://127.0.0.1:${port}/callback`;
+    console.log("Starting local callback server...");
+    // Start callback server (returns promise that resolves when callback is received)
+    const callbackPromise = startCallbackServer(port, {
+        token,
+        timeout: CALLBACK_TIMEOUT,
+    });
+    // Build setup URL and open browser
+    const setupUrl = buildSetupUrl(serverUrl.toString(), token, callbackUrl);
+    console.log(`Opening browser for authentication...`);
+    const browserResult = await openBrowser(setupUrl);
+    if (!browserResult.success) {
+        console.log("");
+        console.log("Could not open browser automatically.");
+        console.log("Please open this URL manually:");
+        console.log("");
+        console.log(`  ${setupUrl}`);
+        console.log("");
+    }
+    console.log("Waiting for setup to complete...");
+    console.log("(This will timeout in 5 minutes)\n");
+    try {
+        // Wait for callback
+        const result = await callbackPromise;
+        // Save config (remove trailing slash from URL)
+        const serverUrlStr = serverUrl.toString().replace(/\/+$/, '');
+        saveConfig({
+            server_url: serverUrlStr,
+            api_key: result.apiKey,
+        });
+        console.log(`✓ Config saved to ${getConfigPath()}`);
+        // Determine hook command
+        let hookCommand;
+        if (options.dev) {
+            // Use local CLI path for development
+            const cliRoot = path.resolve(__dirname, "../..");
+            const indexPath = path.join(cliRoot, "src/index.ts");
+            hookCommand = `npx tsx ${indexPath} send`;
+            console.log(`  Hook command: ${hookCommand}`);
+        }
+        // Install hooks
+        const hookResult = installHooks({ command: hookCommand });
+        if (hookResult.success) {
+            console.log(`✓ ${hookResult.message}`);
+        }
+        else {
+            console.error(`✗ ${hookResult.message}`);
+        }
+        console.log("\n✓ Setup complete!");
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes("Timeout")) {
+            console.error("\n✗ Setup timed out.");
+            console.error("Please try again with: npx agentrace init --url " + options.url);
+        }
+        else {
+            console.error("\n✗ Setup failed:", error instanceof Error ? error.message : error);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/login.d.ts

@@ -0,0 +1 @@
+export declare function loginCommand(): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,40 @@
+import { createWebSession } from "../utils/http.js";
+import * as readline from "node:readline";
+export async function loginCommand() {
+    console.log("Creating login session...\n");
+    const result = await createWebSession();
+    if (!result.ok) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+    }
+    console.log(`Login URL: ${result.data.url}\n`);
+    console.log("Press Enter to open in browser, or Ctrl+C to cancel.\n");
+    // Wait for Enter key
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    await new Promise((resolve) => {
+        rl.question("", () => {
+            rl.close();
+            resolve();
+        });
+    });
+    // Open browser
+    const { exec } = await import("node:child_process");
+    const url = result.data.url;
+    const command = process.platform === "darwin"
+        ? `open "${url}"`
+        : process.platform === "win32"
+            ? `start "${url}"`
+            : `xdg-open "${url}"`;
+    exec(command, (error) => {
+        if (error) {
+            console.error(`Failed to open browser: ${error.message}`);
+            console.log(`Please open this URL manually: ${url}`);
+        }
+        else {
+            console.log("Opened in browser");
+        }
+    });
+}

package/dist/commands/off.d.ts

@@ -0,0 +1 @@
+export declare function offCommand(): Promise<void>;

package/dist/commands/off.js

@@ -0,0 +1,18 @@
+import { uninstallHooks } from "../hooks/installer.js";
+import { loadConfig } from "../config/manager.js";
+export async function offCommand() {
+    // Check if config exists
+    const config = loadConfig();
+    if (!config) {
+        console.log("Agentrace is not configured. Run 'npx agentrace init' first.");
+        return;
+    }
+    const result = uninstallHooks();
+    if (result.success) {
+        console.log(`✓ Hooks disabled. Your credentials are still saved.`);
+        console.log(`  Run 'npx agentrace on' to re-enable.`);
+    }
+    else {
+        console.error(`✗ ${result.message}`);
+    }
+}

package/dist/commands/on.d.ts

@@ -0,0 +1,4 @@
+export interface OnOptions {
+    dev?: boolean;
+}
+export declare function onCommand(options?: OnOptions): Promise<void>;

package/dist/commands/on.js

@@ -0,0 +1,29 @@
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { installHooks } from "../hooks/installer.js";
+import { loadConfig } from "../config/manager.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function onCommand(options = {}) {
+    // Check if config exists
+    const config = loadConfig();
+    if (!config) {
+        console.log("Agentrace is not configured. Run 'npx agentrace init' first.");
+        return;
+    }
+    // Determine hook command
+    let hookCommand;
+    if (options.dev) {
+        // Use local CLI path for development
+        const cliRoot = path.resolve(__dirname, "../..");
+        const indexPath = path.join(cliRoot, "src/index.ts");
+        hookCommand = `npx tsx ${indexPath} send`;
+    }
+    const result = installHooks({ command: hookCommand });
+    if (result.success) {
+        console.log(`✓ Hooks enabled. Session data will be sent to ${config.server_url}`);
+    }
+    else {
+        console.error(`✗ ${result.message}`);
+    }
+}

package/dist/commands/send.d.ts

@@ -0,0 +1 @@
+export declare function sendCommand(): Promise<void>;

package/dist/commands/send.js

@@ -0,0 +1,128 @@
+import { execSync } from "child_process";
+import { loadConfig } from "../config/manager.js";
+import { getNewLines, saveCursor, hasCursor } from "../config/cursor.js";
+import { sendIngest } from "../utils/http.js";
+function getGitRemoteUrl(cwd) {
+    try {
+        const url = execSync("git remote get-url origin", {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        return url || null;
+    }
+    catch {
+        return null; // Not a git repo or no remote
+    }
+}
+function getGitBranch(cwd) {
+    try {
+        const branch = execSync("git branch --show-current", {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        return branch || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function sendCommand() {
+    // Check if config exists
+    const config = loadConfig();
+    if (!config) {
+        console.error("[agentrace] Warning: Config not found. Run 'npx agentrace init' first.");
+        process.exit(0); // Exit 0 to not block hooks
+    }
+    // Read stdin
+    let input = "";
+    try {
+        input = await readStdin();
+    }
+    catch {
+        console.error("[agentrace] Warning: Failed to read stdin");
+        process.exit(0);
+    }
+    if (!input.trim()) {
+        console.error("[agentrace] Warning: Empty input");
+        process.exit(0);
+    }
+    // Parse JSON
+    let data;
+    try {
+        data = JSON.parse(input);
+    }
+    catch {
+        console.error("[agentrace] Warning: Invalid JSON input");
+        process.exit(0);
+    }
+    const sessionId = data.session_id;
+    const transcriptPath = data.transcript_path;
+    if (!sessionId || !transcriptPath) {
+        console.error("[agentrace] Warning: Missing session_id or transcript_path");
+        process.exit(0);
+    }
+    // Get new lines from transcript
+    const { lines, totalLineCount } = getNewLines(transcriptPath, sessionId);
+    if (lines.length === 0) {
+        // No new lines to send
+        process.exit(0);
+    }
+    // Parse JSONL lines
+    const transcriptLines = [];
+    for (const line of lines) {
+        try {
+            transcriptLines.push(JSON.parse(line));
+        }
+        catch {
+            // Skip invalid JSON lines
+        }
+    }
+    if (transcriptLines.length === 0) {
+        process.exit(0);
+    }
+    // Use CLAUDE_PROJECT_DIR (stable project root) instead of cwd (can change during builds)
+    const projectDir = process.env.CLAUDE_PROJECT_DIR || data.cwd;
+    // Extract git info only on first send (when cursor doesn't exist yet)
+    let gitRemoteUrl;
+    let gitBranch;
+    if (projectDir && !hasCursor(sessionId)) {
+        gitRemoteUrl = getGitRemoteUrl(projectDir) ?? undefined;
+        gitBranch = getGitBranch(projectDir) ?? undefined;
+    }
+    // Send to server
+    const result = await sendIngest({
+        session_id: sessionId,
+        transcript_lines: transcriptLines,
+        cwd: projectDir,
+        git_remote_url: gitRemoteUrl,
+        git_branch: gitBranch,
+    });
+    if (result.ok) {
+        // Update cursor on success
+        saveCursor(sessionId, totalLineCount);
+    }
+    else {
+        console.error(`[agentrace] Warning: ${result.error}`);
+    }
+    // Always exit 0 to not block hooks
+    process.exit(0);
+}
+function readStdin() {
+    return new Promise((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", reject);
+        // Set timeout to avoid hanging
+        setTimeout(() => {
+            resolve(data);
+        }, 5000);
+    });
+}

package/dist/commands/uninstall.d.ts

@@ -0,0 +1 @@
+export declare function uninstallCommand(): Promise<void>;

package/dist/commands/uninstall.js

@@ -0,0 +1,22 @@
+import { deleteConfig } from "../config/manager.js";
+import { uninstallHooks } from "../hooks/installer.js";
+export async function uninstallCommand() {
+    console.log("Uninstalling Agentrace...\n");
+    // Remove hooks
+    const hookResult = uninstallHooks();
+    if (hookResult.success) {
+        console.log(`✓ ${hookResult.message}`);
+    }
+    else {
+        console.error(`✗ ${hookResult.message}`);
+    }
+    // Remove config
+    const configRemoved = deleteConfig();
+    if (configRemoved) {
+        console.log("✓ Config removed");
+    }
+    else {
+        console.log("✓ No config to remove");
+    }
+    console.log("\nUninstall complete!");
+}

package/dist/config/cursor.d.ts

@@ -0,0 +1,8 @@
+export declare function getCursor(sessionId: string): number;
+export declare function hasCursor(sessionId: string): boolean;
+export declare function saveCursor(sessionId: string, lineCount: number): void;
+export declare function readTranscriptLines(transcriptPath: string): string[];
+export declare function getNewLines(transcriptPath: string, sessionId: string): {
+    lines: string[];
+    totalLineCount: number;
+};

package/dist/config/cursor.js

@@ -0,0 +1,57 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+const CURSORS_DIR = path.join(os.homedir(), ".agentrace", "cursors");
+function getCursorPath(sessionId) {
+    return path.join(CURSORS_DIR, `${sessionId}.json`);
+}
+export function getCursor(sessionId) {
+    try {
+        const cursorPath = getCursorPath(sessionId);
+        if (!fs.existsSync(cursorPath)) {
+            return 0;
+        }
+        const content = fs.readFileSync(cursorPath, "utf-8");
+        const data = JSON.parse(content);
+        return data.lineCount;
+    }
+    catch {
+        return 0;
+    }
+}
+export function hasCursor(sessionId) {
+    const cursorPath = getCursorPath(sessionId);
+    return fs.existsSync(cursorPath);
+}
+export function saveCursor(sessionId, lineCount) {
+    if (!fs.existsSync(CURSORS_DIR)) {
+        fs.mkdirSync(CURSORS_DIR, { recursive: true });
+    }
+    const data = {
+        lineCount,
+        lastUpdated: new Date().toISOString(),
+    };
+    const cursorPath = getCursorPath(sessionId);
+    fs.writeFileSync(cursorPath, JSON.stringify(data, null, 2));
+}
+export function readTranscriptLines(transcriptPath) {
+    try {
+        if (!fs.existsSync(transcriptPath)) {
+            return [];
+        }
+        const content = fs.readFileSync(transcriptPath, "utf-8");
+        return content.split("\n").filter((line) => line.trim() !== "");
+    }
+    catch {
+        return [];
+    }
+}
+export function getNewLines(transcriptPath, sessionId) {
+    const allLines = readTranscriptLines(transcriptPath);
+    const cursor = getCursor(sessionId);
+    const newLines = allLines.slice(cursor);
+    return {
+        lines: newLines,
+        totalLineCount: allLines.length,
+    };
+}

package/dist/config/manager.d.ts

@@ -0,0 +1,8 @@
+export interface AgentraceConfig {
+    server_url: string;
+    api_key: string;
+}
+export declare function getConfigPath(): string;
+export declare function loadConfig(): AgentraceConfig | null;
+export declare function saveConfig(config: AgentraceConfig): void;
+export declare function deleteConfig(): boolean;

package/dist/config/manager.js

@@ -0,0 +1,38 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+const CONFIG_DIR = path.join(os.homedir(), ".agentrace");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+export function getConfigPath() {
+    return CONFIG_FILE;
+}
+export function loadConfig() {
+    try {
+        if (!fs.existsSync(CONFIG_FILE)) {
+            return null;
+        }
+        const content = fs.readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(config) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export function deleteConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            fs.unlinkSync(CONFIG_FILE);
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/hooks/installer.d.ts

@@ -0,0 +1,12 @@
+export interface InstallHooksOptions {
+    command?: string;
+}
+export declare function installHooks(options?: InstallHooksOptions): {
+    success: boolean;
+    message: string;
+};
+export declare function uninstallHooks(): {
+    success: boolean;
+    message: string;
+};
+export declare function checkHooksInstalled(): boolean;

package/dist/hooks/installer.js

@@ -0,0 +1,100 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
+const DEFAULT_COMMAND = "npx agentrace send";
+function createAgentraceHook(command) {
+    return {
+        type: "command",
+        command,
+    };
+}
+function isAgentraceHook(hook) {
+    // Match both production ("agentrace send") and dev mode ("index.ts send")
+    return hook.command?.includes("agentrace send") || hook.command?.includes("index.ts send");
+}
+export function installHooks(options = {}) {
+    const command = options.command || DEFAULT_COMMAND;
+    const agentraceHook = createAgentraceHook(command);
+    try {
+        let settings = {};
+        // Load existing settings if file exists
+        if (fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+            const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+            settings = JSON.parse(content);
+        }
+        // Initialize hooks structure if not present
+        if (!settings.hooks) {
+            settings.hooks = {};
+        }
+        // Add Stop hook only (transcript diff is sent on each Stop)
+        if (!settings.hooks.Stop) {
+            settings.hooks.Stop = [];
+        }
+        const hasStopHook = settings.hooks.Stop.some((matcher) => matcher.hooks?.some(isAgentraceHook));
+        if (hasStopHook) {
+            return { success: true, message: "Hooks already installed (skipped)" };
+        }
+        settings.hooks.Stop.push({
+            hooks: [agentraceHook],
+        });
+        // Ensure directory exists
+        const dir = path.dirname(CLAUDE_SETTINGS_PATH);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        // Write settings
+        fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+        return { success: true, message: `Hooks added to ${CLAUDE_SETTINGS_PATH}` };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, message: `Failed to install hooks: ${message}` };
+    }
+}
+export function uninstallHooks() {
+    try {
+        if (!fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+            return { success: true, message: "No settings file found" };
+        }
+        const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+        const settings = JSON.parse(content);
+        if (!settings.hooks) {
+            return { success: true, message: "No hooks configured" };
+        }
+        // Remove agentrace hooks from Stop
+        if (settings.hooks.Stop) {
+            settings.hooks.Stop = settings.hooks.Stop.filter((matcher) => !matcher.hooks?.some(isAgentraceHook));
+            if (settings.hooks.Stop.length === 0) {
+                delete settings.hooks.Stop;
+            }
+        }
+        // Clean up empty hooks object
+        if (Object.keys(settings.hooks).length === 0) {
+            delete settings.hooks;
+        }
+        fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+        return {
+            success: true,
+            message: `Removed hooks from ${CLAUDE_SETTINGS_PATH}`,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, message: `Failed to uninstall hooks: ${message}` };
+    }
+}
+export function checkHooksInstalled() {
+    try {
+        if (!fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+            return false;
+        }
+        const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+        const settings = JSON.parse(content);
+        const hasStopHook = settings.hooks?.Stop?.some((matcher) => matcher.hooks?.some(isAgentraceHook));
+        return !!hasStopHook;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { initCommand } from "./commands/init.js";
+import { loginCommand } from "./commands/login.js";
+import { sendCommand } from "./commands/send.js";
+import { uninstallCommand } from "./commands/uninstall.js";
+import { onCommand } from "./commands/on.js";
+import { offCommand } from "./commands/off.js";
+const program = new Command();
+program.name("agentrace").description("CLI for Agentrace").version("0.1.0");
+program
+    .command("init")
+    .description("Initialize agentrace configuration and hooks")
+    .requiredOption("--url <url>", "Server URL (required)")
+    .option("--dev", "Use local CLI path for development")
+    .action(async (options) => {
+    await initCommand({ url: options.url, dev: options.dev });
+});
+program
+    .command("login")
+    .description("Open web dashboard in browser")
+    .action(async () => {
+    await loginCommand();
+});
+program
+    .command("send")
+    .description("Send event to server (used by hooks)")
+    .action(async () => {
+    await sendCommand();
+});
+program
+    .command("uninstall")
+    .description("Remove agentrace hooks and config")
+    .action(async () => {
+    await uninstallCommand();
+});
+program
+    .command("on")
+    .description("Enable agentrace hooks (credentials preserved)")
+    .option("--dev", "Use local CLI path for development")
+    .action(async (options) => {
+    await onCommand({ dev: options.dev });
+});
+program
+    .command("off")
+    .description("Disable agentrace hooks (credentials preserved)")
+    .action(async () => {
+    await offCommand();
+});
+program.parse();

package/dist/utils/browser.d.ts

@@ -0,0 +1,6 @@
+export interface OpenBrowserResult {
+    success: boolean;
+    message: string;
+}
+export declare function openBrowser(url: string): Promise<OpenBrowserResult>;
+export declare function buildSetupUrl(serverUrl: string, token: string, callbackUrl: string): string;

package/dist/utils/browser.js

@@ -0,0 +1,40 @@
+import { exec } from "node:child_process";
+import { platform } from "node:os";
+export async function openBrowser(url) {
+    return new Promise((resolve) => {
+        const os = platform();
+        let command;
+        switch (os) {
+            case "darwin":
+                command = `open "${url}"`;
+                break;
+            case "win32":
+                command = `start "" "${url}"`;
+                break;
+            default:
+                // Linux and others
+                command = `xdg-open "${url}"`;
+                break;
+        }
+        exec(command, (error) => {
+            if (error) {
+                resolve({
+                    success: false,
+                    message: `Failed to open browser: ${error.message}`,
+                });
+            }
+            else {
+                resolve({
+                    success: true,
+                    message: "Browser opened",
+                });
+            }
+        });
+    });
+}
+export function buildSetupUrl(serverUrl, token, callbackUrl) {
+    const url = new URL("/setup", serverUrl);
+    url.searchParams.set("token", token);
+    url.searchParams.set("callback", callbackUrl);
+    return url.toString();
+}

package/dist/utils/callback-server.d.ts

@@ -0,0 +1,10 @@
+export interface CallbackResult {
+    apiKey: string;
+}
+export interface CallbackServerOptions {
+    token: string;
+    timeout: number;
+}
+export declare function getRandomPort(): number;
+export declare function generateToken(): string;
+export declare function startCallbackServer(port: number, options: CallbackServerOptions): Promise<CallbackResult>;

package/dist/utils/callback-server.js

@@ -0,0 +1,81 @@
+import * as http from "node:http";
+import * as crypto from "node:crypto";
+export function getRandomPort() {
+    // Use dynamic port range (49152-65535)
+    return Math.floor(Math.random() * (65535 - 49152 + 1)) + 49152;
+}
+export function generateToken() {
+    return crypto.randomUUID();
+}
+export function startCallbackServer(port, options) {
+    return new Promise((resolve, reject) => {
+        let resolved = false;
+        const server = http.createServer((req, res) => {
+            // Set CORS headers
+            res.setHeader("Access-Control-Allow-Origin", "*");
+            res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+            res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+            // Handle preflight
+            if (req.method === "OPTIONS") {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            // Only accept POST to /callback
+            if (req.method !== "POST" || req.url !== "/callback") {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Not found" }));
+                return;
+            }
+            let body = "";
+            req.on("data", (chunk) => {
+                body += chunk.toString();
+            });
+            req.on("end", () => {
+                try {
+                    const data = JSON.parse(body);
+                    // Validate token
+                    if (data.token !== options.token) {
+                        res.writeHead(401, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Invalid token" }));
+                        return;
+                    }
+                    // Validate api_key
+                    if (!data.api_key || typeof data.api_key !== "string") {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Invalid api_key" }));
+                        return;
+                    }
+                    // Success response
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ success: true }));
+                    resolved = true;
+                    server.close();
+                    resolve({ apiKey: data.api_key });
+                }
+                catch {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Invalid JSON" }));
+                }
+            });
+        });
+        server.on("error", (err) => {
+            if (!resolved) {
+                reject(err);
+            }
+        });
+        // Timeout handling
+        const timeoutId = setTimeout(() => {
+            if (!resolved) {
+                server.close();
+                reject(new Error("Timeout: No callback received"));
+            }
+        }, options.timeout);
+        server.on("close", () => {
+            clearTimeout(timeoutId);
+        });
+        server.listen(port, "127.0.0.1", () => {
+            // Server started successfully
+        });
+    });
+}

package/dist/utils/http.d.ts

@@ -0,0 +1,24 @@
+export interface IngestPayload {
+    session_id: string;
+    transcript_lines: unknown[];
+    cwd?: string;
+    git_remote_url?: string;
+    git_branch?: string;
+}
+export interface IngestResponse {
+    ok: boolean;
+    events_created?: number;
+    error?: string;
+}
+export interface WebSessionResponse {
+    url: string;
+    expires_at: string;
+}
+export declare function sendIngest(payload: IngestPayload): Promise<IngestResponse>;
+export declare function createWebSession(): Promise<{
+    ok: true;
+    data: WebSessionResponse;
+} | {
+    ok: false;
+    error: string;
+}>;

package/dist/utils/http.js

@@ -0,0 +1,56 @@
+import { loadConfig } from "../config/manager.js";
+function getBaseUrl(config) {
+    return config.server_url.replace(/\/+$/, '');
+}
+export async function sendIngest(payload) {
+    const config = loadConfig();
+    if (!config) {
+        return { ok: false, error: "Config not found" };
+    }
+    const url = `${getBaseUrl(config)}/api/ingest`;
+    try {
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${config.api_key}`,
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            return { ok: false, error: `HTTP ${response.status}: ${text}` };
+        }
+        return (await response.json());
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, error: message };
+    }
+}
+export async function createWebSession() {
+    const config = loadConfig();
+    if (!config) {
+        return { ok: false, error: "Config not found. Run 'agentrace init' first." };
+    }
+    const url = `${getBaseUrl(config)}/api/auth/web-session`;
+    try {
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${config.api_key}`,
+            },
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            return { ok: false, error: `HTTP ${response.status}: ${text}` };
+        }
+        const data = (await response.json());
+        return { ok: true, data };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, error: message };
+    }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "agentrace",
+  "version": "0.0.1",
+  "description": "CLI for Agentrace - Claude Code session tracker",
+  "type": "module",
+  "bin": {
+    "agentrace": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "agentrace",
+    "session",
+    "tracker",
+    "cli"
+  ],
+  "author": "satetsu888",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/satetsu888/agentrace.git",
+    "directory": "cli"
+  },
+  "homepage": "https://github.com/satetsu888/agentrace",
+  "bugs": {
+    "url": "https://github.com/satetsu888/agentrace/issues"
+  },
+  "dependencies": {
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}