improving and getting ready for Paid plans

Author: igorcosta

src/core/agent/AgentDependencyComposer.ts

@@ -358,6 +358,7 @@ export function initializeAgentDependencies(
       apiBaseUrl: runtime.config.telemetry?.apiBaseUrl || 'https://api.autohand.ai',
       enableSessionSync: runtime.config.telemetry?.enableSessionSync !== false,
       companySecret: runtime.config.telemetry?.companySecret || runtime.config.api?.companySecret || '',
+      authToken: runtime.config.auth?.token,
       clientVersion: packageJson.version
     });
     host.featureFlagManager = new RemoteFeatureFlagManager(runtime.config);

src/core/agent/AgentSessionAccounting.ts

@@ -106,15 +106,21 @@ function toSyncMessages(messages: SessionMessage[]): Array<{ role: string; conte
   }));
 }
 
-function buildSessionSyncMetadata(host: AgentSessionAccountingHost, endTimeMs: number) {
+function buildSessionSyncMetadata(
+  host: AgentSessionAccountingHost,
+  endTimeMs: number,
+  options: { final?: boolean } = {}
+) {
   const sessionDuration = Math.max(0, endTimeMs - host.sessionStartedAt);
-  return {
+  const metadata = {
     workspaceRoot: host.runtime.workspaceRoot,
     startTime: new Date(host.sessionStartedAt).toISOString(),
-    endTime: new Date(endTimeMs).toISOString(),
     durationSeconds: Math.round(sessionDuration / 1000),
     totalTokens: sessionTotalTokens(host),
   };
+  return options.final
+    ? { ...metadata, endTime: new Date(endTimeMs).toISOString() }
+    : metadata;
 }
 
 export async function syncAgentSessionSnapshot(
@@ -131,7 +137,7 @@ export async function syncAgentSessionSnapshot(
   try {
     await host.telemetryManager.syncSession({
       messages: toSyncMessages(session.getMessages()),
-      metadata: buildSessionSyncMetadata(host, endTimeMs),
+      metadata: buildSessionSyncMetadata(host, endTimeMs, { final: options.force }),
     });
   } finally {
     host.sessionSyncInFlight = false;

src/telemetry/TelemetryClient.ts

@@ -266,10 +266,14 @@ export class TelemetryClient {
       workspaceRoot?: string;
     };
   }): Promise<{ success: boolean; id?: string; error?: string }> {
-    if (!this.config.enabled || !this.config.enableSessionSync) {
+    if (!this.config.enableSessionSync) {
       return { success: false, error: 'Session sync disabled' };
     }
 
+    if (!this.config.authToken) {
+      return { success: false, error: 'Login required for session sync' };
+    }
+
     const online = await this.isOnline();
     if (!online) {
       // Queue for later - store in a separate file
@@ -292,14 +296,12 @@ export class TelemetryClient {
     }
 
     try {
-      // Build auth token: {device_id}.{company_secret}
-      const authToken = `${this.deviceId}.${this.config.companySecret}`;
-
       const response = await fetch(`${this.config.apiBaseUrl}/v1/history`, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
-          'Authorization': `Bearer ${authToken}`
+          'Authorization': `Bearer ${this.config.authToken}`,
+          'X-CLI-Version': this.config.clientVersion || 'unknown'
         },
         body: JSON.stringify({
           deviceId: this.deviceId,

src/telemetry/TelemetryManager.ts

@@ -261,7 +261,6 @@ export class TelemetryManager {
     }
 
     const endTimeMs = Date.now();
-    const endTime = data.metadata?.endTime ?? new Date(endTimeMs).toISOString();
     const startTime = data.metadata?.startTime ?? this.sessionStartTime?.toISOString();
     const durationSeconds = data.metadata?.durationSeconds ?? this.getSessionDurationSeconds(endTimeMs);
 
@@ -273,7 +272,7 @@ export class TelemetryManager {
         provider: this.currentProvider || undefined,
         totalTokens: data.metadata?.totalTokens,
         startTime,
-        endTime,
+        ...(data.metadata?.endTime ? { endTime: data.metadata.endTime } : {}),
         durationSeconds,
         workspaceRoot: data.metadata?.workspaceRoot
       }

src/telemetry/types.ts

@@ -58,6 +58,8 @@ export interface TelemetryConfig {
   enableSessionSync: boolean;
   /** Company secret for API authentication */
   companySecret: string;
+  /** Authenticated Autohand session token for user-scoped features */
+  authToken?: string;
   /** Client type (cli, vscode, zed) */
   clientType: ClientType;
   /** Client/extension version (for non-CLI clients) */

tests/core/agentSessionSync.spec.ts

@@ -67,11 +67,11 @@ describe('agent near-real-time session sync', () => {
       metadata: expect.objectContaining({
         workspaceRoot: '/workspace/project',
         startTime: '2026-05-13T10:00:00.000Z',
-        endTime: '2026-05-13T10:00:13.000Z',
-        durationSeconds: 13,
+        durationSeconds: 18,
         totalTokens: 42,
       }),
     });
+    expect(syncSession.mock.calls[0][0].metadata).not.toHaveProperty('endTime');
   });
 
   it('can force a final snapshot with canonical timing metadata', async () => {

tests/telemetry/TelemetryClient.test.ts

@@ -0,0 +1,82 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import fs from 'fs-extra';
+import { TelemetryClient } from '../../src/telemetry/TelemetryClient.js';
+
+const { tempRoot } = vi.hoisted(() => ({
+  tempRoot: `/tmp/autohand-telemetry-client-${process.pid}`,
+}));
+
+vi.mock('../../src/constants.js', () => ({
+  AUTOHAND_PATHS: {
+    telemetry: `${tempRoot}/telemetry`,
+  },
+  AUTOHAND_FILES: {
+    telemetryQueue: `${tempRoot}/telemetry/queue.json`,
+    sessionSyncQueue: `${tempRoot}/telemetry/session-sync-queue.json`,
+    deviceId: `${tempRoot}/device-id`,
+  },
+}));
+
+describe('TelemetryClient session sync', () => {
+  beforeEach(async () => {
+    await fs.remove(tempRoot);
+    vi.stubGlobal('fetch', vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.endsWith('/health')) {
+        return new Response('ok', { status: 200 });
+      }
+      return new Response(JSON.stringify({ id: 'history-1' }), { status: 200 });
+    }));
+  });
+
+  afterEach(async () => {
+    vi.unstubAllGlobals();
+    await fs.remove(tempRoot);
+  });
+
+  it('does not upload session snapshots without a logged-in auth token', async () => {
+    const client = new TelemetryClient({
+      enabled: false,
+      enableSessionSync: true,
+      apiBaseUrl: 'https://api.example.test',
+    });
+
+    const result = await client.uploadSession({
+      sessionId: 'session-1',
+      messages: [{ role: 'user', content: 'hello' }],
+    });
+
+    expect(result).toEqual({ success: false, error: 'Login required for session sync' });
+    expect(fetch).not.toHaveBeenCalledWith(
+      'https://api.example.test/v1/history',
+      expect.anything()
+    );
+  });
+
+  it('uploads session snapshots with the user auth token even when telemetry events are disabled', async () => {
+    const client = new TelemetryClient({
+      enabled: false,
+      enableSessionSync: true,
+      apiBaseUrl: 'https://api.example.test',
+      authToken: 'auth-token-123',
+      clientVersion: '0.8.2',
+    });
+
+    const result = await client.uploadSession({
+      sessionId: 'session-1',
+      messages: [{ role: 'user', content: 'hello' }],
+    });
+
+    expect(result).toEqual({ success: true, id: 'history-1' });
+    expect(fetch).toHaveBeenCalledWith(
+      'https://api.example.test/v1/history',
+      expect.objectContaining({
+        method: 'POST',
+        headers: expect.objectContaining({
+          Authorization: 'Bearer auth-token-123',
+          'X-CLI-Version': '0.8.2',
+        }),
+      })
+    );
+  });
+});

tests/telemetry/TelemetryManager.test.ts

@@ -105,7 +105,7 @@ describe('TelemetryManager', () => {
     expect(trackSpy).not.toHaveBeenCalled();
   });
 
-  it('includes canonical durationSeconds in synced session metadata', async () => {
+  it('includes canonical durationSeconds in synced active-session metadata without ending the session', async () => {
     const manager = new TelemetryManager({ enabled: true, enableSessionSync: true });
 
     await manager.startSession(
@@ -127,11 +127,39 @@ describe('TelemetryManager', () => {
         model: 'gpt-5',
         provider: 'openai',
         startTime: '2026-05-13T10:00:00.000Z',
-        endTime: '2026-05-13T10:07:30.000Z',
         durationSeconds: 450,
         workspaceRoot: '/workspace/project',
         totalTokens: 123,
       }),
     }));
+    expect(uploadSessionSpy.mock.calls[0][0].metadata).not.toHaveProperty('endTime');
+  });
+
+  it('preserves explicit endTime for final synced session metadata', async () => {
+    const manager = new TelemetryManager({ enabled: true, enableSessionSync: true });
+
+    await manager.startSession(
+      'session-1',
+      'gpt-5',
+      'openai',
+      new Date('2026-05-13T10:00:00.000Z')
+    );
+
+    await manager.syncSession({
+      messages: [{ role: 'user', content: 'done', timestamp: '2026-05-13T10:00:10.000Z' }],
+      metadata: {
+        workspaceRoot: '/workspace/project',
+        endTime: '2026-05-13T10:08:00.000Z',
+        durationSeconds: 480,
+      },
+    });
+
+    expect(uploadSessionSpy).toHaveBeenCalledWith(expect.objectContaining({
+      sessionId: 'session-1',
+      metadata: expect.objectContaining({
+        endTime: '2026-05-13T10:08:00.000Z',
+        durationSeconds: 480,
+      }),
+    }));
   });
 });