@astra-code/astra-ai 0.1.5 → 0.1.7

package/src/lib/backendClient.ts

@@ -7,7 +7,7 @@ import {
 } from "./config.js";
 import type {AgentEvent, AuthSession, ChatMessage} from "../types/events.js";
 import type {WorkspaceFile} from "./workspaceScanner.js";
-import {loadSession} from "./sessionStore.js";
+import {loadSession, saveSession} from "./sessionStore.js";
 
 type JsonRecord = Record<string, unknown>;
 
@@ -22,14 +22,55 @@ export type SessionSummary = {
 export class BackendClient {
   private readonly baseUrl: string;
   private authToken: string | null;
+  private refreshToken: string | null;
+  private onTokenRefreshed: ((session: AuthSession) => void) | null = null;
 
   public constructor(baseUrl = getBackendUrl()) {
     this.baseUrl = baseUrl;
-    this.authToken = loadSession()?.access_token?.trim() || null;
+    const stored = loadSession();
+    this.authToken = stored?.access_token?.trim() || null;
+    this.refreshToken = stored?.refresh_token?.trim() || null;
   }
 
   public setAuthSession(session: AuthSession | null): void {
     this.authToken = session?.access_token?.trim() || null;
+    this.refreshToken = session?.refresh_token?.trim() || null;
+  }
+
+  public setOnTokenRefreshed(cb: (session: AuthSession) => void): void {
+    this.onTokenRefreshed = cb;
+  }
+
+  private async tryRefreshToken(): Promise<boolean> {
+    if (!this.refreshToken) return false;
+    try {
+      const res = await fetch(`${this.baseUrl}/api/auth/refresh`, {
+        method: "POST",
+        headers: {"content-type": "application/json"},
+        body: JSON.stringify({refresh_token: this.refreshToken})
+      });
+      if (!res.ok) return false;
+      const data = (await res.json()) as Record<string, unknown>;
+      const newAccess = typeof data.access_token === "string" ? data.access_token.trim() : null;
+      if (!newAccess) return false;
+      const newRefresh = typeof data.refresh_token === "string" ? data.refresh_token.trim() : this.refreshToken;
+      this.authToken = newAccess;
+      this.refreshToken = newRefresh;
+      // Merge with stored session and persist
+      const stored = loadSession();
+      if (stored) {
+        const refreshed: AuthSession = {
+          ...stored,
+          access_token: newAccess,
+          refresh_token: newRefresh ?? undefined
+        };
+        saveSession(refreshed);
+        this.onTokenRefreshed?.(refreshed);
+      }
+      return true;
+    } catch {
+      return false;
+    }
   }
 
   public async get(path: string, params?: Record<string, string>): Promise<JsonRecord> {
@@ -162,6 +203,24 @@ export class BackendClient {
     return out;
   }
 
+  public async getCliSettings(): Promise<Record<string, unknown>> {
+    try {
+      const data = await this.get("/api/user/cli-settings");
+      return (data.cli_settings as Record<string, unknown>) ?? {};
+    } catch {
+      return {};
+    }
+  }
+
+  public async updateCliSettings(settings: Record<string, unknown>): Promise<Record<string, unknown>> {
+    try {
+      const data = await this.patch("/api/user/cli-settings", settings);
+      return (data.cli_settings as Record<string, unknown>) ?? {};
+    } catch {
+      return {};
+    }
+  }
+
   public async deleteSession(sessionId: string): Promise<void> {
     await this.delete(`/api/sessions/${sessionId}`);
   }
@@ -191,6 +250,7 @@ export class BackendClient {
     workspaceTree?: string[];
     workspaceFiles?: WorkspaceFile[];
     model?: string;
+    signal?: AbortSignal;
   }): AsyncGenerator<AgentEvent, void, void> {
     const model = payload.model ?? getDefaultModel();
     const body = {
@@ -212,20 +272,33 @@ export class BackendClient {
       user_id: payload.user.user_id,
       org_id: payload.user.org_id
     };
-    return this.streamSse("/api/agent/chat/stream", body);
+    return this.streamSse("/api/agent/chat/stream", body, payload.signal);
   }
 
   private async request(url: string, method: string, payload?: JsonRecord): Promise<JsonRecord> {
-    const headers: Record<string, string> = {"content-type": "application/json"};
-    if (this.authToken) {
-      headers.authorization = `Bearer ${this.authToken}`;
-    }
-    const response = await fetch(url, {
+    const makeHeaders = (): Record<string, string> => {
+      const h: Record<string, string> = {"content-type": "application/json"};
+      if (this.authToken) h.authorization = `Bearer ${this.authToken}`;
+      return h;
+    };
+
+    let response = await fetch(url, {
       method,
-      headers,
+      headers: makeHeaders(),
       body: payload ? JSON.stringify(payload) : null
     });
 
+    if (response.status === 401) {
+      const refreshed = await this.tryRefreshToken();
+      if (refreshed) {
+        response = await fetch(url, {
+          method,
+          headers: makeHeaders(),
+          body: payload ? JSON.stringify(payload) : null
+        });
+      }
+    }
+
     if (!response.ok) {
       const detail = (await response.text()).trim();
       throw new Error(`Backend error ${response.status}: ${detail || response.statusText}`);
@@ -238,17 +311,33 @@ export class BackendClient {
     return JSON.parse(text) as JsonRecord;
   }
 
-  private async *streamSse(path: string, payload: JsonRecord): AsyncGenerator<AgentEvent> {
-    const headers: Record<string, string> = {"content-type": "application/json"};
-    if (this.authToken) {
-      headers.authorization = `Bearer ${this.authToken}`;
-    }
-    const response = await fetch(`${this.baseUrl}${path}`, {
+  private async *streamSse(path: string, payload: JsonRecord, signal?: AbortSignal): AsyncGenerator<AgentEvent> {
+    const makeHeaders = (): Record<string, string> => {
+      const h: Record<string, string> = {"content-type": "application/json"};
+      if (this.authToken) h.authorization = `Bearer ${this.authToken}`;
+      return h;
+    };
+    const sig = signal ?? null;
+
+    let response = await fetch(`${this.baseUrl}${path}`, {
       method: "POST",
-      headers,
-      body: JSON.stringify(payload)
+      headers: makeHeaders(),
+      body: JSON.stringify(payload),
+      signal: sig
     });
 
+    if (response.status === 401) {
+      const refreshed = await this.tryRefreshToken();
+      if (refreshed) {
+        response = await fetch(`${this.baseUrl}${path}`, {
+          method: "POST",
+          headers: makeHeaders(),
+          body: JSON.stringify(payload),
+          signal: sig
+        });
+      }
+    }
+
     if (!response.ok) {
       const detail = (await response.text()).trim();
       throw new Error(`Backend error ${response.status}: ${detail || response.statusText}`);

package/src/lib/voice.ts

@@ -1,5 +1,6 @@
 import {spawn, spawnSync} from "child_process";
 import {randomUUID} from "crypto";
+import {existsSync, readFileSync, writeFileSync} from "fs";
 import {basename, join} from "path";
 import {tmpdir} from "os";
 import {readFile, rm} from "fs/promises";
@@ -10,6 +11,101 @@ const VOICE_TEXT_LIMIT = 600;
 const DEFAULT_STT_MODEL = process.env.ASTRA_STT_MODEL?.trim() || "whisper-1";
 const DEFAULT_CHUNK_SECONDS = Number(process.env.ASTRA_STT_CHUNK_SECONDS ?? "2.5");
 
+// Module-level device cache — resolved once per process lifetime.
+// undefined = not yet resolved; null = not configured; string = resolved device (e.g. ":1")
+let _cachedDevice: string | null | undefined = undefined;
+
+/** Read/write the .astra file at the workspace root. */
+const ASTRA_FILE_NAME = ".astra";
+
+const readAstraFile = (workspaceRoot: string): Record<string, string> => {
+  const filePath = join(workspaceRoot, ASTRA_FILE_NAME);
+  if (!existsSync(filePath)) return {};
+  const lines = readFileSync(filePath, "utf8").split("\n");
+  const result: Record<string, string> = {};
+  for (const line of lines) {
+    const eq = line.indexOf("=");
+    if (eq > 0) result[line.slice(0, eq).trim()] = line.slice(eq + 1).trim();
+  }
+  return result;
+};
+
+export const writeAstraKey = (workspaceRoot: string, key: string, value: string): void => {
+  const filePath = join(workspaceRoot, ASTRA_FILE_NAME);
+  const existing = existsSync(filePath) ? readFileSync(filePath, "utf8") : "";
+  const lines = existing.split("\n").filter(l => l.trim() && !l.startsWith(`${key}=`));
+  lines.push(`${key}=${value}`);
+  writeFileSync(filePath, lines.join("\n") + "\n");
+};
+
+/**
+ * Resolve the mic device string for ffmpeg (e.g. ":1").
+ * Priority: in-process cache → .astra file → backend cli_settings → null (needs onboarding).
+ * Writes the value to .astra when fetched from the backend so future runs are instant.
+ */
+export const resolveAudioDevice = async (workspaceRoot: string): Promise<string | null> => {
+  if (_cachedDevice !== undefined) return _cachedDevice;
+
+  // 1. Read local .astra cache
+  const local = readAstraFile(workspaceRoot);
+  if (local.ASTRA_STT_DEVICE) {
+    _cachedDevice = local.ASTRA_STT_DEVICE;
+    return _cachedDevice;
+  }
+
+  // 2. Fetch from backend
+  const token = loadSession()?.access_token;
+  if (token) {
+    try {
+      const resp = await fetch(`${getBackendUrl()}/api/user/cli-settings`, {
+        headers: {Authorization: `Bearer ${token}`}
+      });
+      if (resp.ok) {
+        const data = (await resp.json()) as {cli_settings?: {audio_device_index?: number}};
+        const idx = data.cli_settings?.audio_device_index;
+        if (typeof idx === "number") {
+          const device = `:${idx}`;
+          writeAstraKey(workspaceRoot, "ASTRA_STT_DEVICE", device);
+          _cachedDevice = device;
+          return _cachedDevice;
+        }
+      }
+    } catch {
+      // Silently fall through to onboarding
+    }
+  }
+
+  _cachedDevice = null;
+  return null;
+};
+
+/** Call after onboarding saves a new device so the running process uses it immediately. */
+export const setAudioDevice = (device: string): void => {
+  _cachedDevice = device;
+};
+
+/** List AVFoundation audio devices. Returns [] on non-macOS or if ffmpeg is missing. */
+export const listAvfAudioDevices = (): Array<{index: number; name: string}> => {
+  if (process.platform !== "darwin") return [];
+  const result = spawnSync(
+    "ffmpeg",
+    ["-f", "avfoundation", "-list_devices", "true", "-i", ""],
+    {encoding: "utf8", timeout: 8000}
+  );
+  const output = (result.stderr ?? "") + (result.stdout ?? "");
+  const devices: Array<{index: number; name: string}> = [];
+  let inAudio = false;
+  for (const line of output.split("\n")) {
+    if (line.includes("AVFoundation audio devices")) { inAudio = true; continue; }
+    if (inAudio) {
+      const m = line.match(/\[(\d+)\]\s+(.+)$/);
+      if (m?.[1] && m[2]) devices.push({index: parseInt(m[1], 10), name: m[2].trim()});
+      else if (devices.length) break;
+    }
+  }
+  return devices;
+};
+
 const safeText = (text: string): string => text.replace(/\s+/g, " ").trim().slice(0, VOICE_TEXT_LIMIT);
 
 const commandExists = (binary: string): boolean => {
@@ -39,7 +135,7 @@ const captureAudioChunk = async (seconds: number): Promise<string> => {
     if (process.platform === "darwin") {
       // Prefer ffmpeg on macOS (works on Apple Silicon/Homebrew setups).
       if (commandExists("ffmpeg")) {
-        const micDevice = process.env.ASTRA_STT_DEVICE?.trim() || ":0";
+        const micDevice = _cachedDevice ?? process.env.ASTRA_STT_DEVICE?.trim() ?? ":0";
         cmd = `ffmpeg -hide_banner -loglevel error -f avfoundation -i "${micDevice}" -ar 16000 -ac 1 -t ${seconds} "${outPath}"`;
       } else if (commandExists("rec")) {
         cmd = `rec -q -r 16000 -c 1 "${outPath}" trim 0 ${seconds}`;

package/src/types/events.ts

@@ -5,6 +5,7 @@ export type AuthSession = {
   role?: string;
   display_name?: string;
   access_token?: string;
+  refresh_token?: string;
   [key: string]: unknown;
 };