@raindrop-ai/opencode-plugin 0.1.3 → 0.2.0

package/dist/index.d-vgBcEZbX.d.cts

@@ -0,0 +1,89 @@
+/** Kept structural so public integration declarations do not depend on private schemas. */
+type AppGitOptions = {
+    commitSha?: string | null;
+    commitDirty?: boolean | null;
+    branch?: string | null;
+    detectBranch?: boolean;
+    sourceDirectory?: string;
+    autoDetect?: boolean;
+};
+type IdentifyInput = {
+    userId: string;
+    traits?: Record<string, unknown>;
+};
+type SignalInput = {
+    eventId: string;
+    name: string;
+    type?: "default" | "feedback" | "edit" | "standard" | "agent" | "agent_internal";
+    sentiment?: "POSITIVE" | "NEGATIVE";
+    timestamp?: string;
+    properties?: Record<string, unknown>;
+    attachmentId?: string;
+    comment?: string;
+    after?: string;
+};
+
+/**
+ * Run telemetry egress with OpenTelemetry tracing suppressed.
+ *
+ * Why this exists
+ * ---------------
+ * Raindrop integrations ship spans/events over HTTP with the global `fetch`
+ * (see {@link ../http.ts `postJson`}). When the host app also runs an OTel
+ * fetch/undici instrumentation — e.g. `@vercel/otel`'s `registerOTel`, which
+ * every Eve agent installs — that instrumentation wraps *our own* telemetry
+ * POSTs in a `fetch POST <endpoint>` span. Those spans are then handed to the
+ * very exporter that issued the request, so they get shipped right back to
+ * Raindrop and Workshop as standalone "runs" (and, because each export issues
+ * another fetch, they feed back on themselves). The result is a run list
+ * flooded with `fetch POST .../v1/traces`, `.../events/track_partial` and
+ * `.../live` entries that drown out the real agent turns — especially with
+ * sub-agents, where every sandbox runs its own instrumentation.
+ *
+ * The OTel-blessed fix is to mark the active context as "tracing suppressed"
+ * around the request; instrumentations check `isTracingSuppressed` and return
+ * a no-op span instead of recording one. We do this through a hook stashed on
+ * `globalThis` by the Node entrypoint ({@link ../index.node.ts}) so that:
+ *   - `@opentelemetry/api` / `@opentelemetry/core` stay *optional* — core never
+ *     hard-depends on them, and the hook is simply absent when they (and thus
+ *     any instrumentation to suppress) are not installed; and
+ *   - the browser bundle never pulls in `node:module`, mirroring how core
+ *     injects `AsyncLocalStorage` via `RAINDROP_ASYNC_LOCAL_STORAGE`.
+ *
+ * When no hook is present the callback runs unchanged, so suppression is a
+ * best-effort no-op rather than a hard requirement.
+ */
+/** Hook signature: run `fn` with OTel tracing suppressed, returning its value. */
+type SuppressTracingHook = <T>(fn: () => T) => T;
+declare global {
+    var RAINDROP_SUPPRESS_TRACING: SuppressTracingHook | undefined;
+}
+
+type ParentSpanContext = {
+    traceIdB64: string;
+    spanIdB64: string;
+    eventId: string;
+};
+interface ContextSpan {
+    readonly traceIdB64: string;
+    readonly spanIdB64: string;
+    readonly eventId: string;
+    log?(data: Record<string, unknown>): void;
+}
+interface AsyncLocalStorageLike<T> {
+    getStore(): T | undefined;
+    run<R>(store: T, callback: () => R): R;
+    enterWith?(store: T): void;
+}
+declare abstract class ContextManager {
+    abstract getParentSpanIds(): ParentSpanContext | undefined;
+    abstract runInContext<R>(span: ContextSpan, callback: () => R): R;
+    abstract getCurrentSpan(): ContextSpan | undefined;
+    abstract isReady(): boolean;
+}
+declare global {
+    var RAINDROP_CONTEXT_MANAGER: (new () => ContextManager) | undefined;
+    var RAINDROP_ASYNC_LOCAL_STORAGE: (new <T>() => AsyncLocalStorageLike<T>) | undefined;
+}
+
+export type { AppGitOptions as A, IdentifyInput as I, SignalInput as S };

package/dist/index.d-vgBcEZbX.d.ts

@@ -0,0 +1,89 @@
+/** Kept structural so public integration declarations do not depend on private schemas. */
+type AppGitOptions = {
+    commitSha?: string | null;
+    commitDirty?: boolean | null;
+    branch?: string | null;
+    detectBranch?: boolean;
+    sourceDirectory?: string;
+    autoDetect?: boolean;
+};
+type IdentifyInput = {
+    userId: string;
+    traits?: Record<string, unknown>;
+};
+type SignalInput = {
+    eventId: string;
+    name: string;
+    type?: "default" | "feedback" | "edit" | "standard" | "agent" | "agent_internal";
+    sentiment?: "POSITIVE" | "NEGATIVE";
+    timestamp?: string;
+    properties?: Record<string, unknown>;
+    attachmentId?: string;
+    comment?: string;
+    after?: string;
+};
+
+/**
+ * Run telemetry egress with OpenTelemetry tracing suppressed.
+ *
+ * Why this exists
+ * ---------------
+ * Raindrop integrations ship spans/events over HTTP with the global `fetch`
+ * (see {@link ../http.ts `postJson`}). When the host app also runs an OTel
+ * fetch/undici instrumentation — e.g. `@vercel/otel`'s `registerOTel`, which
+ * every Eve agent installs — that instrumentation wraps *our own* telemetry
+ * POSTs in a `fetch POST <endpoint>` span. Those spans are then handed to the
+ * very exporter that issued the request, so they get shipped right back to
+ * Raindrop and Workshop as standalone "runs" (and, because each export issues
+ * another fetch, they feed back on themselves). The result is a run list
+ * flooded with `fetch POST .../v1/traces`, `.../events/track_partial` and
+ * `.../live` entries that drown out the real agent turns — especially with
+ * sub-agents, where every sandbox runs its own instrumentation.
+ *
+ * The OTel-blessed fix is to mark the active context as "tracing suppressed"
+ * around the request; instrumentations check `isTracingSuppressed` and return
+ * a no-op span instead of recording one. We do this through a hook stashed on
+ * `globalThis` by the Node entrypoint ({@link ../index.node.ts}) so that:
+ *   - `@opentelemetry/api` / `@opentelemetry/core` stay *optional* — core never
+ *     hard-depends on them, and the hook is simply absent when they (and thus
+ *     any instrumentation to suppress) are not installed; and
+ *   - the browser bundle never pulls in `node:module`, mirroring how core
+ *     injects `AsyncLocalStorage` via `RAINDROP_ASYNC_LOCAL_STORAGE`.
+ *
+ * When no hook is present the callback runs unchanged, so suppression is a
+ * best-effort no-op rather than a hard requirement.
+ */
+/** Hook signature: run `fn` with OTel tracing suppressed, returning its value. */
+type SuppressTracingHook = <T>(fn: () => T) => T;
+declare global {
+    var RAINDROP_SUPPRESS_TRACING: SuppressTracingHook | undefined;
+}
+
+type ParentSpanContext = {
+    traceIdB64: string;
+    spanIdB64: string;
+    eventId: string;
+};
+interface ContextSpan {
+    readonly traceIdB64: string;
+    readonly spanIdB64: string;
+    readonly eventId: string;
+    log?(data: Record<string, unknown>): void;
+}
+interface AsyncLocalStorageLike<T> {
+    getStore(): T | undefined;
+    run<R>(store: T, callback: () => R): R;
+    enterWith?(store: T): void;
+}
+declare abstract class ContextManager {
+    abstract getParentSpanIds(): ParentSpanContext | undefined;
+    abstract runInContext<R>(span: ContextSpan, callback: () => R): R;
+    abstract getCurrentSpan(): ContextSpan | undefined;
+    abstract isReady(): boolean;
+}
+declare global {
+    var RAINDROP_CONTEXT_MANAGER: (new () => ContextManager) | undefined;
+    var RAINDROP_ASYNC_LOCAL_STORAGE: (new <T>() => AsyncLocalStorageLike<T>) | undefined;
+}
+
+export type { AppGitOptions as A, IdentifyInput as I, SignalInput as S };

package/dist/index.d.cts

@@ -1,73 +1,10 @@
+import { I as IdentifyInput, A as AppGitOptions } from './index.d-vgBcEZbX.cjs';
 import { Hooks, PluginInput } from '@opencode-ai/plugin';
 
-type IdentifyInput = {
-    userId: string;
-    traits?: Record<string, unknown>;
-};
-
-/**
- * Run telemetry egress with OpenTelemetry tracing suppressed.
- *
- * Why this exists
- * ---------------
- * Raindrop integrations ship spans/events over HTTP with the global `fetch`
- * (see {@link ../http.ts `postJson`}). When the host app also runs an OTel
- * fetch/undici instrumentation — e.g. `@vercel/otel`'s `registerOTel`, which
- * every Eve agent installs — that instrumentation wraps *our own* telemetry
- * POSTs in a `fetch POST <endpoint>` span. Those spans are then handed to the
- * very exporter that issued the request, so they get shipped right back to
- * Raindrop and Workshop as standalone "runs" (and, because each export issues
- * another fetch, they feed back on themselves). The result is a run list
- * flooded with `fetch POST .../v1/traces`, `.../events/track_partial` and
- * `.../live` entries that drown out the real agent turns — especially with
- * sub-agents, where every sandbox runs its own instrumentation.
- *
- * The OTel-blessed fix is to mark the active context as "tracing suppressed"
- * around the request; instrumentations check `isTracingSuppressed` and return
- * a no-op span instead of recording one. We do this through a hook stashed on
- * `globalThis` by the Node entrypoint ({@link ../index.node.ts}) so that:
- *   - `@opentelemetry/api` / `@opentelemetry/core` stay *optional* — core never
- *     hard-depends on them, and the hook is simply absent when they (and thus
- *     any instrumentation to suppress) are not installed; and
- *   - the browser bundle never pulls in `node:module`, mirroring how core
- *     injects `AsyncLocalStorage` via `RAINDROP_ASYNC_LOCAL_STORAGE`.
- *
- * When no hook is present the callback runs unchanged, so suppression is a
- * best-effort no-op rather than a hard requirement.
- */
-/** Hook signature: run `fn` with OTel tracing suppressed, returning its value. */
-type SuppressTracingHook = <T>(fn: () => T) => T;
-declare global {
-    var RAINDROP_SUPPRESS_TRACING: SuppressTracingHook | undefined;
+interface RaindropOpencodeOptions {
+    /** Application Git identity override. false disables enrichment. */
+    appGit?: AppGitOptions | false;
 }
-
-type ParentSpanContext = {
-    traceIdB64: string;
-    spanIdB64: string;
-    eventId: string;
-};
-interface ContextSpan {
-    readonly traceIdB64: string;
-    readonly spanIdB64: string;
-    readonly eventId: string;
-    log?(data: Record<string, unknown>): void;
-}
-interface AsyncLocalStorageLike<T> {
-    getStore(): T | undefined;
-    run<R>(store: T, callback: () => R): R;
-    enterWith?(store: T): void;
-}
-declare abstract class ContextManager {
-    abstract getParentSpanIds(): ParentSpanContext | undefined;
-    abstract runInContext<R>(span: ContextSpan, callback: () => R): R;
-    abstract getCurrentSpan(): ContextSpan | undefined;
-    abstract isReady(): boolean;
-}
-declare global {
-    var RAINDROP_CONTEXT_MANAGER: (new () => ContextManager) | undefined;
-    var RAINDROP_ASYNC_LOCAL_STORAGE: (new <T>() => AsyncLocalStorageLike<T>) | undefined;
-}
-
 /**
  * The Raindrop control handle exposed alongside the OpenCode hooks.
  *
@@ -114,6 +51,6 @@ type RaindropOpencodeHooks = Hooks & {
  *
  * Optional config file: ~/.config/opencode/raindrop.json or .opencode/raindrop.json
  */
-declare function plugin(input: PluginInput): Promise<RaindropOpencodeHooks>;
+declare function plugin(input: PluginInput, opts?: RaindropOpencodeOptions): Promise<RaindropOpencodeHooks>;
 
-export { type IdentifyInput, type RaindropOpencodeHandle, type RaindropOpencodeHooks, plugin as default };
+export { IdentifyInput, type RaindropOpencodeHandle, type RaindropOpencodeHooks, type RaindropOpencodeOptions, plugin as default };

package/dist/index.d.ts

@@ -1,73 +1,10 @@
+import { I as IdentifyInput, A as AppGitOptions } from './index.d-vgBcEZbX.js';
 import { Hooks, PluginInput } from '@opencode-ai/plugin';
 
-type IdentifyInput = {
-    userId: string;
-    traits?: Record<string, unknown>;
-};
-
-/**
- * Run telemetry egress with OpenTelemetry tracing suppressed.
- *
- * Why this exists
- * ---------------
- * Raindrop integrations ship spans/events over HTTP with the global `fetch`
- * (see {@link ../http.ts `postJson`}). When the host app also runs an OTel
- * fetch/undici instrumentation — e.g. `@vercel/otel`'s `registerOTel`, which
- * every Eve agent installs — that instrumentation wraps *our own* telemetry
- * POSTs in a `fetch POST <endpoint>` span. Those spans are then handed to the
- * very exporter that issued the request, so they get shipped right back to
- * Raindrop and Workshop as standalone "runs" (and, because each export issues
- * another fetch, they feed back on themselves). The result is a run list
- * flooded with `fetch POST .../v1/traces`, `.../events/track_partial` and
- * `.../live` entries that drown out the real agent turns — especially with
- * sub-agents, where every sandbox runs its own instrumentation.
- *
- * The OTel-blessed fix is to mark the active context as "tracing suppressed"
- * around the request; instrumentations check `isTracingSuppressed` and return
- * a no-op span instead of recording one. We do this through a hook stashed on
- * `globalThis` by the Node entrypoint ({@link ../index.node.ts}) so that:
- *   - `@opentelemetry/api` / `@opentelemetry/core` stay *optional* — core never
- *     hard-depends on them, and the hook is simply absent when they (and thus
- *     any instrumentation to suppress) are not installed; and
- *   - the browser bundle never pulls in `node:module`, mirroring how core
- *     injects `AsyncLocalStorage` via `RAINDROP_ASYNC_LOCAL_STORAGE`.
- *
- * When no hook is present the callback runs unchanged, so suppression is a
- * best-effort no-op rather than a hard requirement.
- */
-/** Hook signature: run `fn` with OTel tracing suppressed, returning its value. */
-type SuppressTracingHook = <T>(fn: () => T) => T;
-declare global {
-    var RAINDROP_SUPPRESS_TRACING: SuppressTracingHook | undefined;
+interface RaindropOpencodeOptions {
+    /** Application Git identity override. false disables enrichment. */
+    appGit?: AppGitOptions | false;
 }
-
-type ParentSpanContext = {
-    traceIdB64: string;
-    spanIdB64: string;
-    eventId: string;
-};
-interface ContextSpan {
-    readonly traceIdB64: string;
-    readonly spanIdB64: string;
-    readonly eventId: string;
-    log?(data: Record<string, unknown>): void;
-}
-interface AsyncLocalStorageLike<T> {
-    getStore(): T | undefined;
-    run<R>(store: T, callback: () => R): R;
-    enterWith?(store: T): void;
-}
-declare abstract class ContextManager {
-    abstract getParentSpanIds(): ParentSpanContext | undefined;
-    abstract runInContext<R>(span: ContextSpan, callback: () => R): R;
-    abstract getCurrentSpan(): ContextSpan | undefined;
-    abstract isReady(): boolean;
-}
-declare global {
-    var RAINDROP_CONTEXT_MANAGER: (new () => ContextManager) | undefined;
-    var RAINDROP_ASYNC_LOCAL_STORAGE: (new <T>() => AsyncLocalStorageLike<T>) | undefined;
-}
-
 /**
  * The Raindrop control handle exposed alongside the OpenCode hooks.
  *
@@ -114,6 +51,6 @@ type RaindropOpencodeHooks = Hooks & {
  *
  * Optional config file: ~/.config/opencode/raindrop.json or .opencode/raindrop.json
  */
-declare function plugin(input: PluginInput): Promise<RaindropOpencodeHooks>;
+declare function plugin(input: PluginInput, opts?: RaindropOpencodeOptions): Promise<RaindropOpencodeHooks>;
 
-export { type IdentifyInput, type RaindropOpencodeHandle, type RaindropOpencodeHooks, plugin as default };
+export { IdentifyInput, type RaindropOpencodeHandle, type RaindropOpencodeHooks, type RaindropOpencodeOptions, plugin as default };