@raindrop-ai/claude-code 0.0.1

package/dist/cli.js

@@ -0,0 +1,1288 @@
+#!/usr/bin/env node
+
+// src/event-mapper.ts
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import { tmpdir } from "os";
+import { join } from "path";
+
+// ../core/dist/chunk-H6VSZSLN.js
+function getCrypto() {
+  const c = globalThis.crypto;
+  return c;
+}
+function randomBytes(length) {
+  const cryptoObj = getCrypto();
+  const out = new Uint8Array(length);
+  if (cryptoObj && typeof cryptoObj.getRandomValues === "function") {
+    cryptoObj.getRandomValues(out);
+    return out;
+  }
+  for (let i = 0; i < out.length; i++) out[i] = Math.floor(Math.random() * 256);
+  return out;
+}
+function base64Encode(bytes) {
+  const maybeBuffer = globalThis.Buffer;
+  if (maybeBuffer) {
+    return maybeBuffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (let i2 = 0; i2 < bytes.length; i2++) {
+    binary += String.fromCharCode(bytes[i2]);
+  }
+  const btoaFn = globalThis.btoa;
+  if (typeof btoaFn === "function") return btoaFn(binary);
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  let out = "";
+  let i = 0;
+  while (i < binary.length) {
+    const c1 = binary.charCodeAt(i++) & 255;
+    const c2 = i < binary.length ? binary.charCodeAt(i++) & 255 : NaN;
+    const c3 = i < binary.length ? binary.charCodeAt(i++) & 255 : NaN;
+    const e1 = c1 >> 2;
+    const e2 = (c1 & 3) << 4 | (Number.isNaN(c2) ? 0 : c2 >> 4);
+    const e3 = Number.isNaN(c2) ? 64 : (c2 & 15) << 2 | (Number.isNaN(c3) ? 0 : c3 >> 6);
+    const e4 = Number.isNaN(c3) ? 64 : c3 & 63;
+    out += alphabet.charAt(e1);
+    out += alphabet.charAt(e2);
+    out += e3 === 64 ? "=" : alphabet.charAt(e3);
+    out += e4 === 64 ? "=" : alphabet.charAt(e4);
+  }
+  return out;
+}
+function wait(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function formatEndpoint(endpoint) {
+  if (!endpoint) return void 0;
+  return endpoint.endsWith("/") ? endpoint : `${endpoint}/`;
+}
+function parseRetryAfter(headers) {
+  var _a;
+  const value = (_a = headers.get("Retry-After")) != null ? _a : headers.get("retry-after");
+  if (!value) return void 0;
+  const asNumber = Number(value);
+  if (value.trim() !== "" && !Number.isNaN(asNumber)) return asNumber * 1e3;
+  const asDate = new Date(value).getTime();
+  if (!Number.isNaN(asDate)) {
+    const delta = asDate - Date.now();
+    return delta > 0 ? delta : 0;
+  }
+  return void 0;
+}
+function getRetryDelayMs(attemptNumber, previousError) {
+  if (previousError && typeof previousError === "object" && previousError !== null && "retryAfterMs" in previousError) {
+    const v = previousError.retryAfterMs;
+    if (typeof v === "number") return Math.max(0, v);
+  }
+  if (attemptNumber <= 1) return 0;
+  const base = 500;
+  const factor = Math.pow(2, attemptNumber - 2);
+  return base * factor;
+}
+async function withRetry(operation, opName, opts) {
+  const prefix = opts.sdkName ? `[raindrop-ai/${opts.sdkName}]` : "[raindrop-ai/core]";
+  let lastError = void 0;
+  for (let attemptNumber = 1; attemptNumber <= opts.maxAttempts; attemptNumber++) {
+    if (attemptNumber > 1) {
+      const delay = getRetryDelayMs(attemptNumber, lastError);
+      if (opts.debug) {
+        console.warn(
+          `${prefix} ${opName} retry ${attemptNumber}/${opts.maxAttempts} in ${delay}ms`
+        );
+      }
+      if (delay > 0) await wait(delay);
+    } else if (opts.debug) {
+      console.log(`${prefix} ${opName} attempt ${attemptNumber}/${opts.maxAttempts}`);
+    }
+    try {
+      return await operation();
+    } catch (err) {
+      lastError = err;
+      if (opts.debug) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(
+          `${prefix} ${opName} attempt ${attemptNumber} failed: ${msg}${attemptNumber === opts.maxAttempts ? " (no more retries)" : ""}`
+        );
+      }
+      if (lastError && typeof lastError === "object" && "retryable" in lastError && !lastError.retryable)
+        break;
+      if (attemptNumber === opts.maxAttempts) break;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+async function postJson(url, body, headers, opts) {
+  const opName = `POST ${url}`;
+  await withRetry(
+    async () => {
+      const resp = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        },
+        body: JSON.stringify(body)
+      });
+      if (!resp.ok) {
+        const text = await resp.text().catch(() => "");
+        const err = new Error(
+          `HTTP ${resp.status} ${resp.statusText}${text ? `: ${text}` : ""}`
+        );
+        const retryAfterMs = parseRetryAfter(resp.headers);
+        if (typeof retryAfterMs === "number") err.retryAfterMs = retryAfterMs;
+        err.retryable = resp.status === 429 || resp.status >= 500;
+        throw err;
+      }
+    },
+    opName,
+    opts
+  );
+}
+var SpanStatusCode = {
+  UNSET: 0,
+  OK: 1,
+  ERROR: 2
+};
+function createSpanIds(parent) {
+  const traceId = parent ? parent.traceIdB64 : base64Encode(randomBytes(16));
+  const spanId = base64Encode(randomBytes(8));
+  return {
+    traceIdB64: traceId,
+    spanIdB64: spanId,
+    parentSpanIdB64: parent ? parent.spanIdB64 : void 0
+  };
+}
+function nowUnixNanoString() {
+  return Date.now().toString() + "000000";
+}
+function attrString(key, value) {
+  if (value === void 0) return void 0;
+  return { key, value: { stringValue: value } };
+}
+function attrInt(key, value) {
+  if (value === void 0) return void 0;
+  if (!Number.isFinite(value)) return void 0;
+  return { key, value: { intValue: String(Math.trunc(value)) } };
+}
+function buildOtlpSpan(args2) {
+  const attrs = args2.attributes.filter((x) => x !== void 0);
+  const span = {
+    traceId: args2.ids.traceIdB64,
+    spanId: args2.ids.spanIdB64,
+    name: args2.name,
+    startTimeUnixNano: args2.startTimeUnixNano,
+    endTimeUnixNano: args2.endTimeUnixNano
+  };
+  if (args2.ids.parentSpanIdB64) span.parentSpanId = args2.ids.parentSpanIdB64;
+  if (attrs.length) span.attributes = attrs;
+  if (args2.status) span.status = args2.status;
+  return span;
+}
+function buildExportTraceServiceRequest(spans, serviceName = "raindrop.core", serviceVersion = "0.0.0") {
+  return {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: [{ key: "service.name", value: { stringValue: serviceName } }]
+        },
+        scopeSpans: [
+          {
+            scope: { name: serviceName, version: serviceVersion },
+            spans
+          }
+        ]
+      }
+    ]
+  };
+}
+function mergePatches(target, source) {
+  var _a, _b, _c, _d;
+  const out = { ...target, ...source };
+  if (target.properties || source.properties) {
+    out.properties = { ...(_a = target.properties) != null ? _a : {}, ...(_b = source.properties) != null ? _b : {} };
+  }
+  if (target.attachments || source.attachments) {
+    out.attachments = [...(_c = target.attachments) != null ? _c : [], ...(_d = source.attachments) != null ? _d : []];
+  }
+  return out;
+}
+var EventShipper = class {
+  constructor(opts) {
+    this.buffers = /* @__PURE__ */ new Map();
+    this.sticky = /* @__PURE__ */ new Map();
+    this.timers = /* @__PURE__ */ new Map();
+    this.inFlight = /* @__PURE__ */ new Set();
+    var _a, _b, _c, _d, _e, _f, _g;
+    this.writeKey = (_a = opts.writeKey) == null ? void 0 : _a.trim();
+    this.baseUrl = (_b = formatEndpoint(opts.endpoint)) != null ? _b : "https://api.raindrop.ai/v1/";
+    this.enabled = opts.enabled !== false;
+    this.debug = opts.debug;
+    this.partialFlushMs = (_c = opts.partialFlushMs) != null ? _c : 1e3;
+    this.sdkName = (_d = opts.sdkName) != null ? _d : "core";
+    this.prefix = `[raindrop-ai/${this.sdkName}]`;
+    this.defaultEventName = (_e = opts.defaultEventName) != null ? _e : "ai_generation";
+    const isNode = typeof process !== "undefined" && typeof process.version === "string";
+    this.context = {
+      library: {
+        name: (_f = opts.libraryName) != null ? _f : "@raindrop-ai/core",
+        version: (_g = opts.libraryVersion) != null ? _g : "0.0.0"
+      },
+      metadata: {
+        jsRuntime: isNode ? "node" : "web",
+        ...isNode ? { nodeVersion: process.version } : {}
+      }
+    };
+  }
+  isDebugEnabled() {
+    return this.debug;
+  }
+  authHeaders() {
+    return this.writeKey ? { Authorization: `Bearer ${this.writeKey}` } : {};
+  }
+  async patch(eventId, patch) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    if (!this.enabled) return;
+    if (!eventId || !eventId.trim()) return;
+    if (this.debug) {
+      console.log(`${this.prefix} queue patch`, {
+        eventId,
+        userId: patch.userId,
+        convoId: patch.convoId,
+        eventName: patch.eventName,
+        hasInput: typeof patch.input === "string" && patch.input.length > 0,
+        hasOutput: typeof patch.output === "string" && patch.output.length > 0,
+        attachments: (_b = (_a = patch.attachments) == null ? void 0 : _a.length) != null ? _b : 0,
+        isPending: patch.isPending
+      });
+    }
+    const sticky = (_c = this.sticky.get(eventId)) != null ? _c : {};
+    const existing = (_d = this.buffers.get(eventId)) != null ? _d : {};
+    const merged = mergePatches(existing, patch);
+    merged.isPending = (_g = (_f = (_e = patch.isPending) != null ? _e : existing.isPending) != null ? _f : sticky.isPending) != null ? _g : true;
+    this.buffers.set(eventId, merged);
+    this.sticky.set(eventId, {
+      userId: (_h = merged.userId) != null ? _h : sticky.userId,
+      convoId: (_i = merged.convoId) != null ? _i : sticky.convoId,
+      eventName: (_j = merged.eventName) != null ? _j : sticky.eventName,
+      isPending: (_k = merged.isPending) != null ? _k : sticky.isPending
+    });
+    const t = this.timers.get(eventId);
+    if (t) clearTimeout(t);
+    if (merged.isPending === false) {
+      await this.flushOne(eventId);
+      return;
+    }
+    const timeout = setTimeout(() => {
+      void this.flushOne(eventId).catch(() => {
+      });
+    }, this.partialFlushMs);
+    this.timers.set(eventId, timeout);
+  }
+  async finish(eventId, patch) {
+    await this.patch(eventId, { ...patch, isPending: false });
+  }
+  async flush() {
+    if (!this.enabled) return;
+    const ids = [...this.buffers.keys()];
+    await Promise.all(ids.map((id) => this.flushOne(id)));
+    await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+    })));
+  }
+  async shutdown() {
+    for (const t of this.timers.values()) clearTimeout(t);
+    this.timers.clear();
+    await this.flush();
+  }
+  async trackSignal(signal) {
+    var _a, _b;
+    if (!this.enabled) return;
+    const body = [
+      {
+        event_id: signal.eventId,
+        signal_name: signal.name,
+        signal_type: (_a = signal.type) != null ? _a : "default",
+        timestamp: signal.timestamp,
+        sentiment: signal.sentiment,
+        attachment_id: signal.attachmentId,
+        properties: {
+          ...(_b = signal.properties) != null ? _b : {},
+          ...signal.comment ? { comment: signal.comment } : {},
+          ...signal.after ? { after: signal.after } : {}
+        }
+      }
+    ];
+    const url = `${this.baseUrl}signals/track`;
+    try {
+      await postJson(url, body, this.authHeaders(), {
+        maxAttempts: 3,
+        debug: this.debug,
+        sdkName: this.sdkName
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`${this.prefix} failed to send signal (dropping): ${msg}`);
+    }
+  }
+  async identify(users) {
+    if (!this.enabled) return;
+    const list = Array.isArray(users) ? users : [users];
+    const body = list.filter((user) => {
+      if (!(user == null ? void 0 : user.userId) || !user.userId.trim()) {
+        if (this.debug) {
+          console.warn(`${this.prefix} skipping identify: missing userId`);
+        }
+        return false;
+      }
+      return true;
+    }).map((user) => {
+      var _a;
+      return {
+        user_id: user.userId,
+        traits: (_a = user.traits) != null ? _a : {}
+      };
+    });
+    if (body.length === 0) return;
+    const url = `${this.baseUrl}users/identify`;
+    try {
+      await postJson(url, body, this.authHeaders(), {
+        maxAttempts: 3,
+        debug: this.debug,
+        sdkName: this.sdkName
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`${this.prefix} failed to send identify (dropping): ${msg}`);
+    }
+  }
+  async flushOne(eventId) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    if (!this.enabled) return;
+    const timer = this.timers.get(eventId);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(eventId);
+    }
+    const accumulated = this.buffers.get(eventId);
+    this.buffers.delete(eventId);
+    if (!accumulated) return;
+    const sticky = (_a = this.sticky.get(eventId)) != null ? _a : {};
+    const eventName = (_c = (_b = accumulated.eventName) != null ? _b : sticky.eventName) != null ? _c : this.defaultEventName;
+    const userId = (_d = accumulated.userId) != null ? _d : sticky.userId;
+    if (!userId) {
+      if (this.debug) {
+        console.warn(`${this.prefix} skipping track_partial for ${eventId}: missing userId`);
+      }
+      this.sticky.delete(eventId);
+      return;
+    }
+    const { wizardSession, ...restProperties } = (_e = accumulated.properties) != null ? _e : {};
+    const convoId = (_f = accumulated.convoId) != null ? _f : sticky.convoId;
+    const isPending = (_h = (_g = accumulated.isPending) != null ? _g : sticky.isPending) != null ? _h : true;
+    const payload = {
+      event_id: eventId,
+      user_id: userId,
+      event: eventName,
+      timestamp: (_i = accumulated.timestamp) != null ? _i : (/* @__PURE__ */ new Date()).toISOString(),
+      ai_data: {
+        input: accumulated.input,
+        output: accumulated.output,
+        model: accumulated.model,
+        convo_id: convoId
+      },
+      properties: {
+        ...restProperties,
+        ...wizardSession ? { "raindrop.wizardSession": wizardSession } : {},
+        $context: this.context
+      },
+      attachments: accumulated.attachments,
+      is_pending: isPending
+    };
+    const url = `${this.baseUrl}events/track_partial`;
+    if (this.debug) {
+      console.log(`${this.prefix} sending track_partial`, {
+        eventId,
+        eventName,
+        userId,
+        convoId,
+        isPending,
+        inputPreview: typeof accumulated.input === "string" ? accumulated.input.slice(0, 120) : void 0,
+        outputPreview: typeof accumulated.output === "string" ? accumulated.output.slice(0, 120) : void 0,
+        attachments: (_k = (_j = accumulated.attachments) == null ? void 0 : _j.length) != null ? _k : 0,
+        attachmentKinds: (_m = (_l = accumulated.attachments) == null ? void 0 : _l.map((a) => ({
+          type: a.type,
+          role: a.role,
+          name: a.name,
+          valuePreview: a.value.slice(0, 60)
+        }))) != null ? _m : [],
+        endpoint: url
+      });
+    }
+    const p = postJson(url, payload, this.authHeaders(), {
+      maxAttempts: 3,
+      debug: this.debug,
+      sdkName: this.sdkName
+    });
+    this.inFlight.add(p);
+    try {
+      try {
+        await p;
+        if (this.debug) {
+          console.log(`${this.prefix} sent track_partial ${eventId} (${eventName})`);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`${this.prefix} failed to send track_partial (dropping): ${msg}`);
+      }
+    } finally {
+      this.inFlight.delete(p);
+    }
+    if (!isPending) {
+      this.sticky.delete(eventId);
+    }
+  }
+};
+var TraceShipper = class {
+  constructor(opts) {
+    this.queue = [];
+    this.inFlight = /* @__PURE__ */ new Set();
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    this.writeKey = (_a = opts.writeKey) == null ? void 0 : _a.trim();
+    this.baseUrl = (_b = formatEndpoint(opts.endpoint)) != null ? _b : "https://api.raindrop.ai/v1/";
+    this.enabled = opts.enabled !== false;
+    this.debug = opts.debug;
+    this.debugSpans = opts.debugSpans === true;
+    this.flushIntervalMs = (_c = opts.flushIntervalMs) != null ? _c : 1e3;
+    this.maxBatchSize = (_d = opts.maxBatchSize) != null ? _d : 50;
+    this.maxQueueSize = (_e = opts.maxQueueSize) != null ? _e : 5e3;
+    this.sdkName = (_f = opts.sdkName) != null ? _f : "core";
+    this.prefix = `[raindrop-ai/${this.sdkName}]`;
+    this.serviceName = (_g = opts.serviceName) != null ? _g : "raindrop.core";
+    this.serviceVersion = (_h = opts.serviceVersion) != null ? _h : "0.0.0";
+  }
+  isDebugEnabled() {
+    return this.debug;
+  }
+  authHeaders() {
+    return this.writeKey ? { Authorization: `Bearer ${this.writeKey}` } : {};
+  }
+  startSpan(args2) {
+    var _a, _b;
+    const ids = createSpanIds(args2.parent);
+    const started = (_a = args2.startTimeUnixNano) != null ? _a : nowUnixNanoString();
+    const attrs = [
+      attrString("ai.telemetry.metadata.raindrop.eventId", args2.eventId),
+      attrString("ai.operationId", args2.operationId)
+    ];
+    if ((_b = args2.attributes) == null ? void 0 : _b.length) attrs.push(...args2.attributes);
+    return { ids, name: args2.name, startTimeUnixNano: started, attributes: attrs };
+  }
+  endSpan(span, extra) {
+    var _a, _b;
+    if (span.endTimeUnixNano) return;
+    span.endTimeUnixNano = (_a = extra == null ? void 0 : extra.endTimeUnixNano) != null ? _a : nowUnixNanoString();
+    if ((_b = extra == null ? void 0 : extra.attributes) == null ? void 0 : _b.length) {
+      span.attributes.push(...extra.attributes);
+    }
+    let status = extra == null ? void 0 : extra.status;
+    if (!status && (extra == null ? void 0 : extra.error) !== void 0) {
+      const message = extra.error instanceof Error ? extra.error.message : String(extra.error);
+      status = { code: SpanStatusCode.ERROR, message };
+    }
+    const otlp = buildOtlpSpan({
+      ids: span.ids,
+      name: span.name,
+      startTimeUnixNano: span.startTimeUnixNano,
+      endTimeUnixNano: span.endTimeUnixNano,
+      attributes: span.attributes,
+      status
+    });
+    this.enqueue(otlp);
+  }
+  createSpan(args2) {
+    var _a;
+    const ids = createSpanIds(args2.parent);
+    const attrs = [
+      attrString("ai.telemetry.metadata.raindrop.eventId", args2.eventId)
+    ];
+    if ((_a = args2.attributes) == null ? void 0 : _a.length) attrs.push(...args2.attributes);
+    const otlp = buildOtlpSpan({
+      ids,
+      name: args2.name,
+      startTimeUnixNano: args2.startTimeUnixNano,
+      endTimeUnixNano: args2.endTimeUnixNano,
+      attributes: attrs,
+      status: args2.status
+    });
+    this.enqueue(otlp);
+  }
+  enqueue(span) {
+    if (!this.enabled) return;
+    if (this.debugSpans) {
+      const short = (s) => s ? s.slice(-8) : "none";
+      console.log(
+        `${this.prefix}[span] name=${span.name} trace=${short(span.traceId)} span=${short(span.spanId)} parent=${short(
+          span.parentSpanId
+        )}`
+      );
+    }
+    if (this.queue.length >= this.maxQueueSize) {
+      this.queue.shift();
+    }
+    this.queue.push(span);
+    if (this.queue.length >= this.maxBatchSize) {
+      void this.flush().catch(() => {
+      });
+      return;
+    }
+    if (!this.timer) {
+      this.timer = setTimeout(() => {
+        this.timer = void 0;
+        void this.flush().catch(() => {
+        });
+      }, this.flushIntervalMs);
+    }
+  }
+  async flush() {
+    if (!this.enabled) return;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    while (this.queue.length > 0) {
+      const batch = this.queue.splice(0, this.maxBatchSize);
+      const body = buildExportTraceServiceRequest(batch, this.serviceName, this.serviceVersion);
+      const url = `${this.baseUrl}traces`;
+      if (this.debug) {
+        console.log(`${this.prefix} sending traces batch`, {
+          spans: batch.length,
+          endpoint: url
+        });
+      }
+      const p = postJson(url, body, this.authHeaders(), {
+        maxAttempts: 3,
+        debug: this.debug,
+        sdkName: this.sdkName
+      });
+      this.inFlight.add(p);
+      try {
+        try {
+          await p;
+          if (this.debug) console.log(`${this.prefix} sent ${batch.length} spans`);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.warn(`${this.prefix} failed to send ${batch.length} spans: ${msg}`);
+        }
+      } finally {
+        this.inFlight.delete(p);
+      }
+    }
+  }
+  async shutdown() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    await this.flush();
+    await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+    })));
+  }
+};
+
+// ../core/dist/index.node.js
+import { AsyncLocalStorage } from "async_hooks";
+globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = AsyncLocalStorage;
+
+// src/package-info.ts
+var PACKAGE_NAME = "@raindrop-ai/claude-code";
+var PACKAGE_VERSION = "0.0.1";
+
+// src/shipper.ts
+var EventShipper2 = class extends EventShipper {
+  constructor(opts) {
+    var _a, _b, _c, _d;
+    super({
+      ...opts,
+      sdkName: (_a = opts.sdkName) != null ? _a : "claude-code",
+      libraryName: (_b = opts.libraryName) != null ? _b : PACKAGE_NAME,
+      libraryVersion: (_c = opts.libraryVersion) != null ? _c : PACKAGE_VERSION,
+      defaultEventName: (_d = opts.defaultEventName) != null ? _d : "claude_code_session"
+    });
+  }
+};
+var TraceShipper2 = class extends TraceShipper {
+  constructor(opts) {
+    var _a, _b, _c;
+    super({
+      ...opts,
+      sdkName: (_a = opts.sdkName) != null ? _a : "claude-code",
+      serviceName: (_b = opts.serviceName) != null ? _b : "raindrop.claude-code",
+      serviceVersion: (_c = opts.serviceVersion) != null ? _c : PACKAGE_VERSION
+    });
+  }
+  enqueue(span) {
+    var _a;
+    const attrs = (_a = span.attributes) != null ? _a : [];
+    attrs.unshift(
+      { key: "span.id", value: { stringValue: span.spanId } },
+      ...span.parentSpanId ? [{ key: "span.parent.id", value: { stringValue: span.parentSpanId } }] : []
+    );
+    span.attributes = attrs;
+    super.enqueue(span);
+  }
+};
+
+// src/event-mapper.ts
+var MAX_ATTR_LENGTH = 32768;
+function truncate(value) {
+  if (value === void 0) return void 0;
+  if (value.length <= MAX_ATTR_LENGTH) return value;
+  const suffix = "\n...[truncated]";
+  return value.slice(0, MAX_ATTR_LENGTH - suffix.length) + suffix;
+}
+function safeStringify(value) {
+  if (value === void 0 || value === null) return void 0;
+  try {
+    return truncate(JSON.stringify(value));
+  } catch (e) {
+    return truncate(String(value));
+  }
+}
+var STATE_DIR = join(tmpdir(), "raindrop-claude-code");
+function ensureStateDir() {
+  try {
+    mkdirSync(STATE_DIR, { recursive: true });
+  } catch (e) {
+  }
+}
+function safeKey(key) {
+  return key.replace(/[^a-zA-Z0-9_\-]/g, "_");
+}
+function statePath(key) {
+  const sanitized = safeKey(key);
+  const full = join(STATE_DIR, sanitized);
+  if (!full.startsWith(STATE_DIR)) {
+    throw new Error("Path traversal detected");
+  }
+  return full;
+}
+function writeState(key, value) {
+  try {
+    ensureStateDir();
+    writeFileSync(statePath(key), value, "utf-8");
+  } catch (e) {
+  }
+}
+function readState(key) {
+  try {
+    const filePath = statePath(key);
+    if (!existsSync(filePath)) return void 0;
+    return readFileSync(filePath, "utf-8");
+  } catch (e) {
+    return void 0;
+  }
+}
+function deleteState(key) {
+  try {
+    unlinkSync(statePath(key));
+  } catch (e) {
+  }
+}
+function turnEventKey(sessionId) {
+  return `event_${sessionId}`;
+}
+function saveCurrentEventId(sessionId, eventId) {
+  writeState(turnEventKey(sessionId), eventId);
+}
+function getCurrentEventId(sessionId) {
+  const saved = readState(turnEventKey(sessionId));
+  if (saved) return saved;
+  return `cc_${sessionId}`;
+}
+function saveSpanContext(key, ctx) {
+  writeState(key, JSON.stringify(ctx));
+}
+function readSpanContext(key) {
+  const raw = readState(key);
+  if (!raw) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch (e) {
+    return void 0;
+  }
+}
+function rootSpanKey(sessionId) {
+  return `rootspan_${sessionId}`;
+}
+function subagentSpanKey(agentId) {
+  return `subagentspan_${agentId}`;
+}
+function getParentContext(payload) {
+  if (payload.agent_id) {
+    const sub = readSpanContext(subagentSpanKey(payload.agent_id));
+    if (sub) return sub;
+  }
+  return readSpanContext(rootSpanKey(payload.session_id));
+}
+function saveTimestamp(key) {
+  writeState(key, String(Date.now()));
+}
+function readTimestamp(key) {
+  const raw = readState(key);
+  deleteState(key);
+  if (!raw) return void 0;
+  const ts = parseInt(raw, 10);
+  return Number.isFinite(ts) ? ts : void 0;
+}
+async function mapHookToRaindrop(payload, config, eventShipper, traceShipper) {
+  var _a;
+  const convoId = payload.session_id;
+  const baseProperties = {
+    cwd: payload.cwd,
+    permission_mode: payload.permission_mode,
+    plugin_version: PACKAGE_VERSION,
+    ...payload.agent_id ? { agent_id: payload.agent_id } : {},
+    ...payload.agent_type ? { agent_type: payload.agent_type } : {}
+  };
+  switch (payload.hook_event_name) {
+    case "SessionStart":
+      writeState(`model_${payload.session_id}`, (_a = payload.model) != null ? _a : "");
+      break;
+    case "UserPromptSubmit":
+      await handleUserPromptSubmit(payload, convoId, config, baseProperties, eventShipper, traceShipper);
+      break;
+    case "PreToolUse":
+      handlePreToolUse(payload);
+      break;
+    case "PostToolUse":
+      handlePostToolUse(payload, getCurrentEventId(payload.session_id), traceShipper);
+      break;
+    case "PostToolUseFailure":
+      handlePostToolUseFailure(payload, getCurrentEventId(payload.session_id), traceShipper);
+      break;
+    case "Stop":
+      await handleStop(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper);
+      break;
+    case "StopFailure":
+      await handleStopFailure(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper);
+      break;
+    case "SubagentStart":
+      handleSubagentStart(payload, getCurrentEventId(payload.session_id), traceShipper);
+      break;
+    case "SubagentStop":
+      handleSubagentStop(payload, getCurrentEventId(payload.session_id), traceShipper);
+      break;
+    case "PermissionDenied":
+      handlePermissionDenied(payload, getCurrentEventId(payload.session_id), traceShipper);
+      break;
+    case "PostCompact":
+      await handlePostCompact(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper);
+      break;
+    case "SessionEnd":
+      await handleSessionEnd(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper);
+      deleteState(turnEventKey(payload.session_id));
+      deleteState(rootSpanKey(payload.session_id));
+      deleteState(`model_${payload.session_id}`);
+      break;
+    default:
+      if (config.debug) {
+        console.log(`[raindrop-ai/claude-code] ignoring unhandled event: ${payload.hook_event_name}`);
+      }
+  }
+}
+async function handleUserPromptSubmit(payload, convoId, config, properties, eventShipper, traceShipper) {
+  const eventId = `cc_${randomUUID2()}`;
+  saveCurrentEventId(payload.session_id, eventId);
+  const model = readState(`model_${payload.session_id}`) || void 0;
+  const rootSpan = traceShipper.startSpan({
+    name: model != null ? model : "claude-code",
+    eventId,
+    attributes: [
+      attrString("ai.operationId", "generateText"),
+      attrString("session.model", model),
+      attrString("cwd", payload.cwd)
+    ]
+  });
+  traceShipper.endSpan(rootSpan);
+  saveSpanContext(rootSpanKey(payload.session_id), {
+    traceIdB64: rootSpan.ids.traceIdB64,
+    spanIdB64: rootSpan.ids.spanIdB64
+  });
+  const patch = {
+    isPending: true,
+    userId: config.userId,
+    convoId,
+    eventName: "claude_code_session",
+    input: payload.prompt,
+    model,
+    properties
+  };
+  await eventShipper.patch(eventId, patch);
+}
+function handlePreToolUse(payload) {
+  if (payload.tool_use_id) {
+    saveTimestamp(`tool_${payload.tool_use_id}`);
+  }
+}
+function createToolSpan(payload, eventId, traceShipper, error) {
+  const endMs = Date.now();
+  const savedStartMs = payload.tool_use_id ? readTimestamp(`tool_${payload.tool_use_id}`) : void 0;
+  const startMs = savedStartMs && savedStartMs <= endMs ? savedStartMs : endMs;
+  const durationMs = endMs - startMs;
+  const startNano = String(startMs) + "000000";
+  const endNano = String(endMs) + "000000";
+  const parent = getParentContext(payload);
+  traceShipper.createSpan({
+    name: "ai.toolCall",
+    eventId,
+    parent,
+    startTimeUnixNano: startNano,
+    endTimeUnixNano: endNano,
+    attributes: [
+      attrString("ai.operationId", "ai.toolCall"),
+      attrString("ai.toolCall.name", payload.tool_name),
+      attrString("ai.toolCall.id", payload.tool_use_id),
+      attrString("ai.toolCall.args", safeStringify(payload.tool_input)),
+      ...payload.tool_response != null ? [attrString("ai.toolCall.result", safeStringify(payload.tool_response))] : [],
+      attrInt("traceloop.entity.duration_ms", durationMs)
+    ],
+    ...error ? { status: { code: 2, message: error } } : {}
+  });
+}
+function handlePostToolUse(payload, eventId, traceShipper) {
+  createToolSpan(payload, eventId, traceShipper);
+}
+function handlePostToolUseFailure(payload, eventId, traceShipper) {
+  var _a;
+  createToolSpan(payload, eventId, traceShipper, (_a = payload.error) != null ? _a : "Tool execution failed");
+}
+function handleSubagentStart(payload, eventId, traceShipper) {
+  if (payload.agent_id) {
+    saveTimestamp(`subagent_${payload.agent_id}`);
+  }
+  const parent = getParentContext(payload);
+  const span = traceShipper.startSpan({
+    name: "ai.subagent.start",
+    eventId,
+    parent,
+    attributes: [
+      attrString("ai.operationId", "ai.subagent"),
+      attrString("ai.subagent.id", payload.agent_id),
+      attrString("ai.subagent.type", payload.agent_type)
+    ]
+  });
+  traceShipper.endSpan(span);
+  if (payload.agent_id) {
+    saveSpanContext(subagentSpanKey(payload.agent_id), {
+      traceIdB64: span.ids.traceIdB64,
+      spanIdB64: span.ids.spanIdB64
+    });
+  }
+}
+function handleSubagentStop(payload, eventId, traceShipper) {
+  const endMs = Date.now();
+  const savedStartMs = payload.agent_id ? readTimestamp(`subagent_${payload.agent_id}`) : void 0;
+  const startMs = savedStartMs && savedStartMs <= endMs ? savedStartMs : endMs;
+  const durationMs = endMs - startMs;
+  const startNano = String(startMs) + "000000";
+  const endNano = String(endMs) + "000000";
+  const parent = readSpanContext(rootSpanKey(payload.session_id));
+  traceShipper.createSpan({
+    name: "ai.subagent",
+    eventId,
+    parent,
+    startTimeUnixNano: startNano,
+    endTimeUnixNano: endNano,
+    attributes: [
+      attrString("ai.operationId", "ai.subagent"),
+      attrString("ai.subagent.id", payload.agent_id),
+      attrString("ai.subagent.type", payload.agent_type),
+      attrString("ai.subagent.result", safeStringify(payload.last_assistant_message)),
+      attrInt("traceloop.entity.duration_ms", durationMs)
+    ]
+  });
+  if (payload.agent_id) {
+    deleteState(subagentSpanKey(payload.agent_id));
+  }
+}
+function handlePermissionDenied(payload, eventId, traceShipper) {
+  var _a;
+  const parent = getParentContext(payload);
+  traceShipper.createSpan({
+    name: "ai.permissionDenied",
+    eventId,
+    parent,
+    startTimeUnixNano: nowUnixNanoString(),
+    endTimeUnixNano: nowUnixNanoString(),
+    attributes: [
+      attrString("ai.operationId", "ai.permissionDenied"),
+      attrString("ai.toolCall.name", payload.tool_name),
+      attrString("ai.toolCall.id", payload.tool_use_id),
+      attrString("ai.toolCall.args", safeStringify(payload.tool_input)),
+      attrString("ai.permissionDenied.reason", payload.reason)
+    ],
+    status: {
+      code: 2,
+      message: (_a = payload.reason) != null ? _a : "Permission denied"
+    }
+  });
+}
+async function handlePostCompact(payload, eventId, config, properties, eventShipper) {
+  await eventShipper.patch(eventId, {
+    isPending: true,
+    userId: config.userId,
+    convoId: payload.session_id,
+    eventName: "claude_code_session",
+    properties: {
+      ...properties,
+      compaction_trigger: payload.trigger,
+      compact_summary: payload.compact_summary
+    }
+  });
+}
+async function handleStop(payload, eventId, config, properties, eventShipper) {
+  await eventShipper.finish(eventId, {
+    userId: config.userId,
+    output: payload.last_assistant_message,
+    properties
+  });
+}
+async function handleStopFailure(payload, eventId, config, properties, eventShipper) {
+  await eventShipper.finish(eventId, {
+    userId: config.userId,
+    output: payload.last_assistant_message,
+    properties: {
+      ...properties,
+      error: payload.error,
+      error_details: payload.error_details
+    }
+  });
+}
+async function handleSessionEnd(payload, eventId, config, properties, eventShipper) {
+  await eventShipper.finish(eventId, {
+    userId: config.userId,
+    properties: {
+      ...properties,
+      session_end_reason: payload.reason
+    }
+  });
+}
+
+// src/config.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { homedir, userInfo } from "os";
+import { join as join2 } from "path";
+var CONFIG_PATH = join2(homedir(), ".config", "raindrop", "config.json");
+function loadConfig() {
+  var _a, _b, _c, _d, _e, _f, _g;
+  let file = {};
+  try {
+    if (existsSync2(CONFIG_PATH)) {
+      file = JSON.parse(readFileSync2(CONFIG_PATH, "utf-8"));
+    }
+  } catch (e) {
+  }
+  const systemUser = (() => {
+    try {
+      return userInfo().username;
+    } catch (e) {
+      return "unknown";
+    }
+  })();
+  return {
+    writeKey: (_b = (_a = process.env["RAINDROP_WRITE_KEY"]) != null ? _a : file.write_key) != null ? _b : "",
+    endpoint: (_d = (_c = process.env["RAINDROP_API_URL"]) != null ? _c : file.api_url) != null ? _d : "https://api.raindrop.ai/v1",
+    userId: (_f = (_e = process.env["RAINDROP_USER_ID"]) != null ? _e : file.user_id) != null ? _f : systemUser,
+    debug: process.env["RAINDROP_DEBUG"] === "true" ? true : (_g = file.debug) != null ? _g : false
+  };
+}
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+
+// src/hook-handler.ts
+var STDIN_TIMEOUT_MS = 5e3;
+function readStdin() {
+  return new Promise((resolve2) => {
+    if (process.stdin.isTTY) {
+      resolve2("");
+      return;
+    }
+    const chunks = [];
+    let resolved = false;
+    function done(value) {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(timeout);
+      process.stdin.removeAllListeners();
+      process.stdin.destroy();
+      resolve2(value);
+    }
+    const timeout = setTimeout(() => {
+      done(chunks.length > 0 ? Buffer.concat(chunks).toString("utf-8") : "");
+    }, STDIN_TIMEOUT_MS);
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => done(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("error", () => done(chunks.length > 0 ? Buffer.concat(chunks).toString("utf-8") : ""));
+  });
+}
+async function handleHook() {
+  const raw = await readStdin();
+  if (!raw.trim()) {
+    return;
+  }
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch (e) {
+    return;
+  }
+  if (!payload.session_id || !payload.hook_event_name) {
+    return;
+  }
+  const config = loadConfig();
+  if (!config.writeKey) {
+    return;
+  }
+  const mapperConfig = {
+    userId: config.userId,
+    debug: config.debug
+  };
+  const eventShipper = new EventShipper2({
+    writeKey: config.writeKey,
+    endpoint: config.endpoint,
+    debug: config.debug
+  });
+  const traceShipper = new TraceShipper2({
+    writeKey: config.writeKey,
+    endpoint: config.endpoint,
+    debug: config.debug
+  });
+  try {
+    await mapHookToRaindrop(payload, mapperConfig, eventShipper, traceShipper);
+    await Promise.all([eventShipper.flush(), traceShipper.flush()]);
+    await Promise.all([eventShipper.shutdown(), traceShipper.shutdown()]);
+  } catch (err) {
+    if (config.debug) {
+      console.error(
+        `[raindrop-ai/claude-code] error processing hook: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+}
+
+// src/setup.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2, userInfo as userInfo2 } from "os";
+import { dirname, join as join3, resolve } from "path";
+import { createInterface } from "readline";
+function getClaudeSettingsPath(scope, cwd) {
+  if (scope === "project") {
+    return resolve(cwd, ".claude", "settings.json");
+  }
+  return join3(homedir2(), ".claude", "settings.json");
+}
+var HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "SubagentStart",
+  "SubagentStop",
+  "PermissionDenied",
+  "PostCompact",
+  "Stop",
+  "StopFailure",
+  "SessionEnd"
+];
+function makeHookConfig() {
+  const hooks = {};
+  for (const event of HOOK_EVENTS) {
+    hooks[event] = [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: "raindrop-claude-code hook",
+            async: true,
+            timeout: 10
+          }
+        ]
+      }
+    ];
+  }
+  return hooks;
+}
+function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+async function runSetup(args2) {
+  var _a, _b, _c, _d, _e;
+  const scope = (_a = args2.scope) != null ? _a : "user";
+  const scopeLabel = scope === "project" ? "project" : "global";
+  console.log("\n  Raindrop \xD7 Claude Code \u2014 Setup\n");
+  let writeKey = (_c = (_b = args2.writeKey) != null ? _b : process.env["RAINDROP_WRITE_KEY"]) != null ? _c : "";
+  if (!writeKey) {
+    writeKey = await prompt("  Enter your Raindrop write key: ");
+  }
+  if (!writeKey) {
+    console.error("\n  Error: write key is required. Get it from https://app.raindrop.ai\n");
+    process.exit(1);
+  }
+  let userId = (_d = args2.userId) != null ? _d : "";
+  if (!userId) {
+    try {
+      userId = userInfo2().username;
+    } catch (e) {
+      userId = "unknown";
+    }
+  }
+  const configPath = getConfigPath();
+  const configDir = dirname(configPath);
+  mkdirSync2(configDir, { recursive: true });
+  let existingConfig = {};
+  try {
+    if (existsSync3(configPath)) {
+      existingConfig = JSON.parse(readFileSync3(configPath, "utf-8"));
+    }
+  } catch (e) {
+  }
+  const raindropConfig = {
+    ...existingConfig,
+    write_key: writeKey,
+    user_id: userId
+  };
+  writeFileSync2(configPath, JSON.stringify(raindropConfig, null, 2) + "\n", "utf-8");
+  console.log(`  Saved Raindrop config to ${configPath}`);
+  const settingsPath = getClaudeSettingsPath(scope, process.cwd());
+  const settingsDir = dirname(settingsPath);
+  mkdirSync2(settingsDir, { recursive: true });
+  let settings = {};
+  if (existsSync3(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
+    } catch (e) {
+      console.warn(`  Warning: could not parse ${settingsPath}, creating fresh`);
+      settings = {};
+    }
+  }
+  const existingHooks = (_e = settings["hooks"]) != null ? _e : {};
+  const newHooks = makeHookConfig();
+  for (const [event, hookGroups] of Object.entries(newHooks)) {
+    const existing = existingHooks[event];
+    if (!existing || !Array.isArray(existing)) {
+      existingHooks[event] = hookGroups;
+      continue;
+    }
+    const typedExisting = existing;
+    const alreadyHasRaindrop = typedExisting.some(
+      (group) => {
+        var _a2;
+        return (_a2 = group.hooks) == null ? void 0 : _a2.some((h) => typeof h["command"] === "string" && h["command"].includes("raindrop-claude-code"));
+      }
+    );
+    if (!alreadyHasRaindrop) {
+      typedExisting.push(...hookGroups);
+    }
+  }
+  settings["hooks"] = existingHooks;
+  writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  console.log(`  Updated Claude Code hooks in ${settingsPath} (${scopeLabel})`);
+  const { execSync } = await import("child_process");
+  const whichCmd = process.platform === "win32" ? "where" : "which";
+  try {
+    execSync(`${whichCmd} raindrop-claude-code`, { stdio: "ignore" });
+  } catch (e) {
+    console.log(`
+  Warning: 'raindrop-claude-code' is not in your PATH.
+  The hooks need the binary globally available. Run:
+
+    npm install -g @raindrop-ai/claude-code
+`);
+  }
+  console.log(`
+  Done! Claude Code will now send telemetry to Raindrop.
+  Scope: ${scopeLabel}
+  User ID: ${userId}
+
+  To verify, start a Claude Code session and check your Raindrop dashboard.
+  Set RAINDROP_DEBUG=true for verbose logging.
+`);
+}
+
+// src/cli.ts
+var args = process.argv.slice(2);
+var command = args[0];
+function parseFlag(name) {
+  const prefix = `--${name}=`;
+  const flag = args.find((a) => a.startsWith(prefix));
+  return flag ? flag.slice(prefix.length) : void 0;
+}
+async function main() {
+  switch (command) {
+    case "setup": {
+      const scopeRaw = parseFlag("scope");
+      const scope = scopeRaw === "project" ? "project" : scopeRaw === "user" ? "user" : void 0;
+      await runSetup({
+        writeKey: parseFlag("write-key"),
+        userId: parseFlag("user-id"),
+        scope
+      });
+      break;
+    }
+    case "hook": {
+      await handleHook();
+      break;
+    }
+    case "version":
+    case "--version":
+    case "-v": {
+      console.log(`${PACKAGE_NAME} ${PACKAGE_VERSION}`);
+      break;
+    }
+    case "help":
+    case "--help":
+    case "-h":
+    default: {
+      console.log(`
+  ${PACKAGE_NAME} v${PACKAGE_VERSION}
+
+  Raindrop observability for Claude Code CLI.
+
+  Commands:
+    setup               Configure Claude Code hooks for Raindrop
+      --write-key=KEY   Raindrop write key (or set RAINDROP_WRITE_KEY)
+      --user-id=ID      User identifier (defaults to system username)
+      --scope=SCOPE     "user" (global, default) or "project" (.claude/ in cwd)
+
+    hook                Handle a Claude Code hook event (reads JSON from stdin)
+    version             Print version
+    help                Show this help message
+
+  Environment:
+    RAINDROP_WRITE_KEY  API write key (alternative to --write-key or config file)
+    RAINDROP_USER_ID    User ID override
+    RAINDROP_API_URL    Custom API endpoint
+    RAINDROP_DEBUG      Set to "true" for verbose logging
+`);
+      if (!command || command === "help" || command === "--help" || command === "-h") {
+        process.exit(0);
+      } else {
+        console.error(`  Unknown command: ${command}
+`);
+        process.exit(1);
+      }
+    }
+  }
+}
+main().catch((err) => {
+  console.error(`[raindrop-ai/claude-code] fatal: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(command === "hook" ? 0 : 1);
+});