@timefly/opencode-plugin 0.2.0

package/README.md

@@ -0,0 +1,244 @@
+# @timefly/opencode-plugin
+
+TimeFly telemetry for [OpenCode](https://opencode.ai). Tracks sessions, models, tokens, tool calls, and errors — **not** prompt content.
+
+## Quick start
+
+```bash
+# 1. Add plugin to OpenCode config
+bunx @timefly/opencode-plugin setup-opencode -- --target user
+
+# 2. Sign in with your TimeFly account (Google OAuth)
+bunx @timefly/opencode-plugin login
+
+# 3. Restart OpenCode
+```
+
+You need a **TimeFly Supporter** plan for sync. Free accounts can install the plugin but `POST /ai/sync` returns 403.
+
+## Installation (step by step)
+
+### Prerequisites
+
+- [OpenCode](https://opencode.ai) installed and working
+- [Bun](https://bun.sh) (OpenCode uses it internally; you need it for `bunx`)
+- TimeFly account with **Supporter** plan ([pricing](https://timefly.dev/pricing))
+
+### Option A — npm (when published)
+
+```bash
+# Global plugin (all projects on this machine)
+bunx @timefly/opencode-plugin setup-opencode -- --target user
+
+# Sign in once
+bunx @timefly/opencode-plugin login
+
+# Restart OpenCode
+```
+
+### Option B — one project only
+
+```bash
+bunx @timefly/opencode-plugin setup-opencode -- --target project --project /path/to/your/repo
+bunx @timefly/opencode-plugin login
+# restart OpenCode in that project
+```
+
+Writes to `./opencode.json` in the project root.
+
+### Option C — local development (monorepo)
+
+```bash
+cd ai-integrations
+bun install
+bun run build
+
+bun run --filter @timefly/opencode-plugin setup-opencode -- --target user --local
+bun run --filter @timefly/opencode-plugin login
+# restart OpenCode
+```
+
+`--local` adds an absolute path to `dist/index.js` instead of the npm package name.
+
+### What `setup-opencode` changes
+
+It merges into your OpenCode config (does not overwrite other settings):
+
+| Target | Config file |
+|--------|-------------|
+| `--target user` | `~/.config/opencode/opencode.json` (Windows: `%USERPROFILE%\.config\opencode\opencode.json`) |
+| `--target project` | `<project>/opencode.json` |
+
+Example result:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["@timefly/opencode-plugin"]
+}
+```
+
+OpenCode loads plugins at startup. **You must restart OpenCode** after install or config changes.
+
+### Verify it is loaded
+
+After restart, use OpenCode normally (send a prompt, run a tool). Check:
+
+1. OpenCode logs — warnings if not signed in or not Supporter
+2. TimeFly dashboard → **AI Usage** card (may take ~10s after backend ingest)
+3. Local queue file — if sync fails, events appear in `<project>/.timefly-ai-queue.json`
+
+## How auth works
+
+OpenCode plugins run inside the OpenCode process. There is no built-in TimeFly UI inside OpenCode — auth is handled outside:
+
+| Step | What happens |
+|------|----------------|
+| `login` | Opens browser → Google OAuth → saves tokens to `~/.config/opencode/timefly-auth.json` |
+| Plugin startup | Reads auth file (or `TIMEFLY_ACCESS_TOKEN` env override) |
+| Each sync | Sends `Authorization: Bearer <accessToken>` to `POST /ai/sync` |
+| Token expiry | SDK auto-refreshes using `refreshToken` (~30 days) and updates the auth file |
+| No auth | Events queue locally in `.timefly-ai-queue.json` (project cwd) |
+
+Manual env override (not recommended — access tokens expire in ~15 minutes):
+
+```bash
+export TIMEFLY_ACCESS_TOKEN="..."
+export TIMEFLY_API_BASE_URL="https://api.timefly.dev"
+```
+
+## How sync works
+
+Unlike the VS Code extension (which syncs on a timer every ~2 minutes), the OpenCode plugin syncs **on every event** — there is no background interval.
+
+### Timing — when does data leave your machine?
+
+| Trigger | What happens |
+|---------|----------------|
+| LLM request (`chat.params`) | Immediate sync attempt |
+| Assistant turn completes | Immediate sync attempt |
+| Tool call / result | Immediate sync attempt |
+| Session start / end | Immediate sync attempt |
+| Next event after failure | Retries queued events first, then sends new ones |
+
+**Typical flow during a coding session:**
+
+1. You send a prompt → `llm_request` syncs (~instant)
+2. Model responds → `turn_complete` + `llm_response` sync (~instant when turn finishes)
+3. Agent runs tools → each `tool_call` / `tool_result` syncs
+4. Session goes idle → `session_end` with session totals syncs
+
+So sync frequency = **how active OpenCode is**, not a fixed cron. A busy session with 10 tool calls and 3 LLM turns can produce 20+ HTTP requests in a few minutes.
+
+### What each sync request does
+
+```
+1. flushPendingQueue()     ← retry anything in .timefly-ai-queue.json
+2. gzip JSON batch         ← usually 1–3 events per request
+3. POST /ai/sync           ← Bearer token from auth file
+4. Gateway                 ← JWT validate + Supporter role check
+5. Ingest → Redis queue    ← accepted immediately (202-style)
+6. Backend worker (~5s)    ← drains Redis → ClickHouse
+7. Dashboard               ← reads aggregated data from ClickHouse
+```
+
+End-to-end latency: **~1–10 seconds** from event to dashboard (network + 5s worker poll).
+
+### Offline queue
+
+If sync fails (no network, 401, 403), events append to:
+
+```
+<OpenCode project cwd>/.timefly-ai-queue.json
+```
+
+On the **next successful sync**, the SDK flushes this file first. Nothing is lost unless you delete the file.
+
+### Auth file location
+
+```
+~/.config/opencode/timefly-auth.json
+```
+
+```json
+{
+  "accessToken": "...",
+  "refreshToken": "...",
+  "apiBaseUrl": "https://api.timefly.dev",
+  "savedAt": "2026-06-20T..."
+}
+```
+
+Access token expires in ~15 minutes; the SDK refreshes automatically using `refreshToken` (~30 days).
+
+### Architecture diagram
+
+```
+OpenCode hooks → @timefly/opencode-plugin → @timefly/ai-sdk
+  → POST /ai/sync (gzip JSON, Bearer token)
+  → Gateway auth + Supporter check
+  → Ingest queue (Redis)
+  → Worker (every 5s) → ClickHouse ai_usage_events
+  → Dashboard GET /analytics/ai-usage
+```
+
+If sync fails:
+
+- **401** — run `login` again
+- **403** — upgrade to Supporter at [timefly.dev/pricing](https://timefly.dev/pricing)
+- **Network** — events stay in local queue and retry on next event
+
+Errors are logged via OpenCode's `client.app.log()` (service: `timefly-opencode-plugin`).
+
+## Install options (quick reference)
+
+```bash
+# Global (all projects)
+bunx @timefly/opencode-plugin setup-opencode -- --target user
+
+# Single project
+bunx @timefly/opencode-plugin setup-opencode -- --target project --project /path/to/repo
+
+# Local dev build
+bun run --filter @timefly/opencode-plugin setup-opencode -- --target user --local
+bun run --filter @timefly/opencode-plugin login
+```
+
+### Manual config
+
+Add to `opencode.json` or `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["@timefly/opencode-plugin"]
+}
+```
+
+OpenCode installs npm plugins automatically at startup via Bun.
+
+## Environment
+
+| Variable | Required | Default |
+|----------|----------|---------|
+| Auth file from `login` | Recommended | `~/.config/opencode/timefly-auth.json` |
+| `TIMEFLY_ACCESS_TOKEN` | Optional override | — |
+| `TIMEFLY_API_BASE_URL` | No | `https://api.timefly.dev` |
+| `TIMEFLY_OPENCODE_SESSION_ID` | No | OpenCode session ID |
+
+## Events captured
+
+| OpenCode signal | TimeFly `eventType` | Data |
+|-----------------|---------------------|------|
+| `session.created` | `session_start` | title, project, directory |
+| `session.idle` | `session_end` | session token/tool/request totals |
+| `chat.params` | `llm_request` | model, provider, agent, temperature |
+| `message.updated` (assistant, completed) | `turn_complete` + `llm_response` | tokens, duration, tokens/s, cost |
+| `message.part.updated` (step-finish) | `llm_response` | per-step tokens |
+| `tool.execute.*` | `tool_call` / `tool_result` | tool name, output length |
+| `session.compacted` / compaction | `compaction` | auto/manual |
+| `session.error` / retry | `error` | error metadata |
+
+## Privacy
+
+Metadata and token counts only. No prompts, responses, or file contents. See [docs/PRIVACY.md](../../docs/PRIVACY.md).

package/dist/event-handlers.d.ts

@@ -0,0 +1,14 @@
+import { createEventTracker } from './event-tracker.js';
+import { type OpenCodeBusEvent } from './opencode-readers.js';
+import type { createEventPublisher } from './publish-events.js';
+type EventPublisher = ReturnType<typeof createEventPublisher>['publish'];
+export declare const handleSessionCreated: (eventProperties: Record<string, unknown>, publish: EventPublisher) => Promise<void>;
+export declare const handleSessionIdle: (eventProperties: Record<string, unknown>, tracker: ReturnType<typeof createEventTracker>, publish: EventPublisher) => Promise<void>;
+export declare const handleMessageUpdated: (eventProperties: Record<string, unknown>, tracker: ReturnType<typeof createEventTracker>, publish: EventPublisher) => Promise<void>;
+export declare const handleMessagePartUpdated: (eventProperties: Record<string, unknown>, tracker: ReturnType<typeof createEventTracker>, publish: EventPublisher) => Promise<void>;
+export declare const handleSessionCompacted: (eventProperties: Record<string, unknown>, publish: EventPublisher) => Promise<void>;
+export declare const handleSessionError: (eventProperties: Record<string, unknown>, publish: EventPublisher) => Promise<void>;
+export declare const handleCommandExecuted: (eventProperties: Record<string, unknown>, publish: EventPublisher) => Promise<void>;
+export declare const handleBusEvent: (event: OpenCodeBusEvent, tracker: ReturnType<typeof createEventTracker>, publish: EventPublisher) => Promise<void>;
+export {};
+//# sourceMappingURL=event-handlers.d.ts.map

package/dist/event-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-handlers.d.ts","sourceRoot":"","sources":["../src/event-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAiBvD,OAAO,EASN,KAAK,gBAAgB,EACrB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAG/D,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,SAAS,CAAC,CAAA;AAKxE,eAAO,MAAM,oBAAoB,GAAI,iBAAiB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,cAAc,KAAG,OAAO,CAAC,IAAI,CAapH,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC7B,iBAAiB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,SAAS,UAAU,CAAC,OAAO,kBAAkB,CAAC,EAC9C,SAAS,cAAc,KACrB,OAAO,CAAC,IAAI,CAad,CAAA;AAED,eAAO,MAAM,oBAAoB,GAChC,iBAAiB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,SAAS,UAAU,CAAC,OAAO,kBAAkB,CAAC,EAC9C,SAAS,cAAc,KACrB,OAAO,CAAC,IAAI,CAwCd,CAAA;AAED,eAAO,MAAM,wBAAwB,GACpC,iBAAiB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,SAAS,UAAU,CAAC,OAAO,kBAAkB,CAAC,EAC9C,SAAS,cAAc,KACrB,OAAO,CAAC,IAAI,CAiCd,CAAA;AAED,eAAO,MAAM,sBAAsB,GAClC,iBAAiB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,SAAS,cAAc,KACrB,OAAO,CAAC,IAAI,CAQd,CAAA;AAED,eAAO,MAAM,kBAAkB,GAC9B,iBAAiB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,SAAS,cAAc,KACrB,OAAO,CAAC,IAAI,CAmBd,CAAA;AAED,eAAO,MAAM,qBAAqB,GACjC,iBAAiB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,SAAS,cAAc,KACrB,OAAO,CAAC,IAAI,CAad,CAAA;AAED,eAAO,MAAM,cAAc,GAC1B,OAAO,gBAAgB,EACvB,SAAS,UAAU,CAAC,OAAO,kBAAkB,CAAC,EAC9C,SAAS,cAAc,KACrB,OAAO,CAAC,IAAI,CAyBd,CAAA"}

package/dist/event-handlers.js

@@ -0,0 +1,145 @@
+import { mapAssistantLlmResponseInput, mapAssistantTurnCompleteInput, mapCommandExecutedInput, mapCompactionInput, mapCompactionPartInput, mapErrorInput, mapRetryPartInput, mapSessionEndInput, mapSessionStartInput, mapStepFinishInput, mapUserMessageInput } from './map-opencode-event.js';
+import { readAssistantMessage, readCompactionPart, readEventProperties, readRetryPart, readSessionIdFromProperties, readSessionInfo, readStepFinishPart, readUserMessage } from './opencode-readers.js';
+import { sumTokenUsage } from './token-usage.js';
+const isRecord = (value) => typeof value === 'object' && value !== null;
+export const handleSessionCreated = (eventProperties, publish) => {
+    const sessionInfo = readSessionInfo(eventProperties.info);
+    if (!sessionInfo) {
+        return Promise.resolve();
+    }
+    return publish([
+        {
+            eventType: 'session_start',
+            ...mapSessionStartInput(sessionInfo)
+        }
+    ]);
+};
+export const handleSessionIdle = (eventProperties, tracker, publish) => {
+    const sessionId = readSessionIdFromProperties(eventProperties);
+    if (!sessionId) {
+        return Promise.resolve();
+    }
+    return publish([
+        {
+            eventType: 'session_end',
+            ...mapSessionEndInput(sessionId, tracker.getSessionStats(sessionId))
+        }
+    ]);
+};
+export const handleMessageUpdated = (eventProperties, tracker, publish) => {
+    const assistantMessage = readAssistantMessage(eventProperties.info);
+    if (assistantMessage) {
+        if (assistantMessage.time.completed === undefined || tracker.hasProcessedMessage(assistantMessage.id)) {
+            return Promise.resolve();
+        }
+        tracker.markMessageProcessed(assistantMessage.id);
+        const eventsToPublish = [mapAssistantTurnCompleteInput(assistantMessage), mapAssistantLlmResponseInput(assistantMessage)].filter((eventInput) => eventInput !== undefined);
+        if (!eventsToPublish.length) {
+            return Promise.resolve();
+        }
+        tracker.recordSessionStats(assistantMessage.sessionID, {
+            inputTokens: assistantMessage.tokens.input,
+            outputTokens: assistantMessage.tokens.output,
+            totalTokens: sumTokenUsage(assistantMessage.tokens),
+            turnCount: 1
+        });
+        return publish(eventsToPublish);
+    }
+    const userMessage = readUserMessage(eventProperties.info);
+    if (userMessage) {
+        if (tracker.hasProcessedUserMessage(userMessage.id)) {
+            return Promise.resolve();
+        }
+        tracker.markUserMessageProcessed(userMessage.id);
+        return publish([mapUserMessageInput(userMessage)]);
+    }
+    return Promise.resolve();
+};
+export const handleMessagePartUpdated = (eventProperties, tracker, publish) => {
+    const stepFinishPart = readStepFinishPart(eventProperties.part);
+    const retryPart = readRetryPart(eventProperties.part);
+    const compactionPart = readCompactionPart(eventProperties.part);
+    if (stepFinishPart) {
+        if (tracker.hasProcessedPart(stepFinishPart.id)) {
+            return Promise.resolve();
+        }
+        tracker.markPartProcessed(stepFinishPart.id);
+        return publish([mapStepFinishInput(stepFinishPart)]);
+    }
+    if (retryPart) {
+        if (tracker.hasProcessedPart(retryPart.id)) {
+            return Promise.resolve();
+        }
+        tracker.markPartProcessed(retryPart.id);
+        return publish([mapRetryPartInput(retryPart)]);
+    }
+    if (compactionPart) {
+        if (tracker.hasProcessedPart(compactionPart.id)) {
+            return Promise.resolve();
+        }
+        tracker.markPartProcessed(compactionPart.id);
+        return publish([mapCompactionPartInput(compactionPart)]);
+    }
+    return Promise.resolve();
+};
+export const handleSessionCompacted = (eventProperties, publish) => {
+    const sessionId = readSessionIdFromProperties(eventProperties);
+    if (!sessionId) {
+        return Promise.resolve();
+    }
+    return publish([mapCompactionInput(sessionId)]);
+};
+export const handleSessionError = (eventProperties, publish) => {
+    const sessionId = readSessionIdFromProperties(eventProperties);
+    const errorRecord = isRecord(eventProperties.error) ? eventProperties.error : undefined;
+    const errorName = errorRecord && typeof errorRecord.name === 'string' ? errorRecord.name : 'unknown';
+    const errorData = errorRecord && isRecord(errorRecord.data) ? errorRecord.data : undefined;
+    const errorMessage = errorData && typeof errorData.message === 'string' ? errorData.message : 'OpenCode session error';
+    if (!sessionId) {
+        return Promise.resolve();
+    }
+    return publish([
+        mapErrorInput(sessionId, {
+            error_name: errorName,
+            error_message: errorMessage,
+            error_scope: 'session'
+        })
+    ]);
+};
+export const handleCommandExecuted = (eventProperties, publish) => {
+    if (typeof eventProperties.name !== 'string' || typeof eventProperties.sessionID !== 'string') {
+        return Promise.resolve();
+    }
+    return publish([
+        mapCommandExecutedInput({
+            sessionID: eventProperties.sessionID,
+            name: eventProperties.name,
+            arguments: typeof eventProperties.arguments === 'string' ? eventProperties.arguments : '',
+            messageID: typeof eventProperties.messageID === 'string' ? eventProperties.messageID : 'unknown'
+        })
+    ]);
+};
+export const handleBusEvent = (event, tracker, publish) => {
+    const eventProperties = readEventProperties(event);
+    if (!eventProperties || typeof event.type !== 'string') {
+        return Promise.resolve();
+    }
+    switch (event.type) {
+        case 'session.created':
+            return handleSessionCreated(eventProperties, publish);
+        case 'session.idle':
+            return handleSessionIdle(eventProperties, tracker, publish);
+        case 'message.updated':
+            return handleMessageUpdated(eventProperties, tracker, publish);
+        case 'message.part.updated':
+            return handleMessagePartUpdated(eventProperties, tracker, publish);
+        case 'session.compacted':
+            return handleSessionCompacted(eventProperties, publish);
+        case 'session.error':
+            return handleSessionError(eventProperties, publish);
+        case 'command.executed':
+            return handleCommandExecuted(eventProperties, publish);
+        default:
+            return Promise.resolve();
+    }
+};

package/dist/event-tracker.d.ts

@@ -0,0 +1,21 @@
+export type SessionStats = {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    turnCount: number;
+    toolCallCount: number;
+    requestCount: number;
+    stepCount: number;
+};
+export type EventTracker = {
+    hasProcessedMessage: (messageId: string) => boolean;
+    markMessageProcessed: (messageId: string) => void;
+    hasProcessedUserMessage: (messageId: string) => boolean;
+    markUserMessageProcessed: (messageId: string) => void;
+    hasProcessedPart: (partId: string) => boolean;
+    markPartProcessed: (partId: string) => void;
+    recordSessionStats: (sessionId: string, delta: Partial<SessionStats>) => void;
+    getSessionStats: (sessionId: string) => SessionStats;
+};
+export declare const createEventTracker: () => EventTracker;
+//# sourceMappingURL=event-tracker.d.ts.map

package/dist/event-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-tracker.d.ts","sourceRoot":"","sources":["../src/event-tracker.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG;IAC1B,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;IACrB,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;CACjB,CAAA;AAYD,MAAM,MAAM,YAAY,GAAG;IAC1B,mBAAmB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;IACnD,oBAAoB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;IACjD,uBAAuB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;IACvD,wBAAwB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;IACrD,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAA;IAC7C,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3C,kBAAkB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,IAAI,CAAA;IAC7E,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,YAAY,CAAA;CACpD,CAAA;AAED,eAAO,MAAM,kBAAkB,QAAO,YAiCrC,CAAA"}

package/dist/event-tracker.js

@@ -0,0 +1,42 @@
+const emptySessionStats = () => ({
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    turnCount: 0,
+    toolCallCount: 0,
+    requestCount: 0,
+    stepCount: 0
+});
+export const createEventTracker = () => {
+    const processedMessageIds = new Set();
+    const processedUserMessageIds = new Set();
+    const processedPartIds = new Set();
+    const sessionStatsById = new Map();
+    return {
+        hasProcessedMessage: (messageId) => processedMessageIds.has(messageId),
+        markMessageProcessed: (messageId) => {
+            processedMessageIds.add(messageId);
+        },
+        hasProcessedUserMessage: (messageId) => processedUserMessageIds.has(messageId),
+        markUserMessageProcessed: (messageId) => {
+            processedUserMessageIds.add(messageId);
+        },
+        hasProcessedPart: (partId) => processedPartIds.has(partId),
+        markPartProcessed: (partId) => {
+            processedPartIds.add(partId);
+        },
+        recordSessionStats: (sessionId, delta) => {
+            const currentStats = sessionStatsById.get(sessionId) ?? emptySessionStats();
+            sessionStatsById.set(sessionId, {
+                inputTokens: currentStats.inputTokens + (delta.inputTokens ?? 0),
+                outputTokens: currentStats.outputTokens + (delta.outputTokens ?? 0),
+                totalTokens: currentStats.totalTokens + (delta.totalTokens ?? 0),
+                turnCount: currentStats.turnCount + (delta.turnCount ?? 0),
+                toolCallCount: currentStats.toolCallCount + (delta.toolCallCount ?? 0),
+                requestCount: currentStats.requestCount + (delta.requestCount ?? 0),
+                stepCount: currentStats.stepCount + (delta.stepCount ?? 0)
+            });
+        },
+        getSessionStats: (sessionId) => sessionStatsById.get(sessionId) ?? emptySessionStats()
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '@opencode-ai/plugin';
+export declare const timeflyOpenCodePlugin: Plugin;
+export default timeflyOpenCodePlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAUjD,eAAO,MAAM,qBAAqB,EAAE,MA0CnC,CAAA;AAED,eAAe,qBAAqB,CAAA"}

package/dist/index.js

@@ -0,0 +1,43 @@
+import { createEventTracker } from './event-tracker.js';
+import { handleBusEvent } from './event-handlers.js';
+import { mapCompactionInput, mapLlmRequestInput, mapToolCallInput, mapToolResultInput } from './map-opencode-event.js';
+import { createEventPublisher } from './publish-events.js';
+import packageJson from '../package.json' with { type: 'json' };
+const PLUGIN_VERSION = packageJson.version;
+export const timeflyOpenCodePlugin = ({ client }) => {
+    const tracker = createEventTracker();
+    const publisher = createEventPublisher(client, PLUGIN_VERSION);
+    return Promise.resolve({
+        event: (input) => handleBusEvent(input.event, tracker, publisher.publish),
+        'chat.params': (input, output) => {
+            tracker.recordSessionStats(input.sessionID, { requestCount: 1 });
+            return publisher.publish([
+                mapLlmRequestInput({
+                    sessionID: input.sessionID,
+                    agent: input.agent,
+                    providerId: input.provider.info.id,
+                    modelId: input.model.id,
+                    providerSource: input.provider.source,
+                    temperature: output.temperature,
+                    topP: output.topP,
+                    maxOutputTokens: output.maxOutputTokens
+                })
+            ]);
+        },
+        'tool.execute.before': (input) => {
+            tracker.recordSessionStats(input.sessionID, { toolCallCount: 1 });
+            return publisher.publish([mapToolCallInput(input)]);
+        },
+        'tool.execute.after': (input, output) => publisher.publish([
+            mapToolResultInput({
+                sessionID: input.sessionID,
+                tool: input.tool,
+                callID: input.callID,
+                hasOutput: Boolean(output.output),
+                outputLength: output.output.length
+            })
+        ]),
+        'experimental.session.compacting': (input) => publisher.publish([mapCompactionInput(input.sessionID)])
+    });
+};
+export default timeflyOpenCodePlugin;

package/dist/install.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=install.d.ts.map

package/dist/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../src/install.ts"],"names":[],"mappings":""}

package/dist/install.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env bun
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolveDefaultAuthFilePath } from '@timefly/ai-sdk';
+const PLUGIN_PACKAGE_NAME = '@timefly/opencode-plugin';
+const PRICING_URL = 'https://timefly.dev/pricing';
+const currentDirectory = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(currentDirectory, '..');
+const localPluginPath = path.join(packageRoot, 'dist', 'index.js');
+const parseArguments = (argumentsList) => {
+    const targetFlagIndex = argumentsList.findIndex((argument) => argument === '--target');
+    const projectFlagIndex = argumentsList.findIndex((argument) => argument === '--project');
+    const useLocalPath = argumentsList.includes('--local');
+    const targetValue = targetFlagIndex >= 0 ? argumentsList[targetFlagIndex + 1] : 'user';
+    const projectValue = projectFlagIndex >= 0 ? argumentsList[projectFlagIndex + 1] : undefined;
+    if (targetValue !== 'user' && targetValue !== 'project') {
+        throw new Error('Invalid --target. Use "user" or "project".');
+    }
+    return {
+        target: targetValue,
+        projectPath: projectValue,
+        useLocalPath
+    };
+};
+const resolveConfigDestination = (options) => {
+    if (options.target === 'project') {
+        if (!options.projectPath) {
+            throw new Error('--project is required when --target project');
+        }
+        return path.join(path.resolve(options.projectPath), 'opencode.json');
+    }
+    const homeDirectory = process.env.HOME ?? process.env.USERPROFILE;
+    if (!homeDirectory) {
+        throw new Error('Could not resolve home directory for user-level install');
+    }
+    return path.join(homeDirectory, '.config', 'opencode', 'opencode.json');
+};
+const readConfigFile = (configPath) => readFile(configPath, 'utf8')
+    .then((configContent) => JSON.parse(configContent))
+    .catch((error) => {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+        return {};
+    }
+    throw error;
+});
+const resolvePluginEntry = (options) => options.useLocalPath ? localPluginPath.replaceAll('\\', '/') : PLUGIN_PACKAGE_NAME;
+const pluginEntryExists = (pluginList, pluginEntry) => (pluginList ?? []).some((entry) => (Array.isArray(entry) ? entry[0] : entry) === pluginEntry);
+const mergePluginConfig = (config, pluginEntry) => {
+    if (pluginEntryExists(config.plugin, pluginEntry)) {
+        return config;
+    }
+    return {
+        ...config,
+        $schema: config.$schema ?? 'https://opencode.ai/config.json',
+        plugin: [...(config.plugin ?? []), pluginEntry]
+    };
+};
+const printPostInstallInstructions = (configPath) => {
+    const authFilePath = resolveDefaultAuthFilePath();
+    console.log('');
+    console.log('TimeFly OpenCode plugin installed.');
+    console.log(`OpenCode config: ${configPath}`);
+    console.log('');
+    console.log('Next steps:');
+    console.log('  1. Sign in (stores tokens in ~/.config/opencode/timefly-auth.json):');
+    console.log('     bunx @timefly/opencode-plugin login');
+    console.log('  2. You need a TimeFly Supporter plan for sync to work.');
+    console.log(`     Upgrade: ${PRICING_URL}`);
+    console.log('  3. Restart OpenCode.');
+    console.log('');
+    console.log('Optional env overrides:');
+    console.log('  TIMEFLY_API_BASE_URL=https://api.timefly.dev');
+    console.log('  TIMEFLY_ACCESS_TOKEN=...  (manual token, expires in ~15 min without refresh file)');
+    console.log('');
+    console.log(`Auth file: ${authFilePath}`);
+};
+const installPlugin = (options) => {
+    const configPath = resolveConfigDestination(options);
+    const configDirectory = path.dirname(configPath);
+    const pluginEntry = resolvePluginEntry(options);
+    return mkdir(configDirectory, { recursive: true })
+        .then(() => readConfigFile(configPath))
+        .then((config) => mergePluginConfig(config, pluginEntry))
+        .then((mergedConfig) => writeFile(configPath, `${JSON.stringify(mergedConfig, null, 2)}\n`, 'utf8'))
+        .then(() => {
+        printPostInstallInstructions(configPath);
+    });
+};
+const run = () => {
+    const options = parseArguments(process.argv.slice(2));
+    return installPlugin(options);
+};
+run().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[timefly-opencode-install] ${message}`);
+    process.exit(1);
+});

package/dist/login.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=login.d.ts.map

package/dist/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../src/login.ts"],"names":[],"mappings":""}