@astra-code/astra-ai 0.1.0 → 0.1.1

package/src/lib/backendClient.ts

@@ -7,6 +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";
 
 type JsonRecord = Record<string, unknown>;
 
@@ -20,9 +21,15 @@ export type SessionSummary = {
 
 export class BackendClient {
   private readonly baseUrl: string;
+  private authToken: string | null;
 
   public constructor(baseUrl = getBackendUrl()) {
     this.baseUrl = baseUrl;
+    this.authToken = loadSession()?.access_token?.trim() || null;
+  }
+
+  public setAuthSession(session: AuthSession | null): void {
+    this.authToken = session?.access_token?.trim() || null;
   }
 
   public async get(path: string, params?: Record<string, string>): Promise<JsonRecord> {
@@ -68,6 +75,30 @@ export class BackendClient {
     }
   }
 
+  public async getUserProfile(session: AuthSession): Promise<AuthSession> {
+    const data = await this.get("/api/user/profile", {
+      user_id: session.user_id,
+      org_id: session.org_id
+    });
+    const profile = data as Record<string, unknown>;
+    const merged: AuthSession = {
+      ...session,
+    };
+    const email = typeof profile.email === "string" && profile.email ? profile.email : session.email;
+    const role = typeof profile.role === "string" ? profile.role : session.role;
+    const displayName = typeof profile.display_name === "string" ? profile.display_name : session.display_name;
+    if (email) {
+      merged.email = email;
+    }
+    if (role) {
+      merged.role = role;
+    }
+    if (displayName) {
+      merged.display_name = displayName;
+    }
+    return merged;
+  }
+
   public async ensureSessionId(
     user: AuthSession,
     existingSessionId: string | null,
@@ -185,9 +216,13 @@ export class BackendClient {
   }
 
   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, {
       method,
-      headers: {"content-type": "application/json"},
+      headers,
       body: payload ? JSON.stringify(payload) : null
     });
 
@@ -204,9 +239,13 @@ export class BackendClient {
   }
 
   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}`, {
       method: "POST",
-      headers: {"content-type": "application/json"},
+      headers,
       body: JSON.stringify(payload)
     });
 

package/src/lib/voice.ts

@@ -10,6 +10,11 @@ const DEFAULT_CHUNK_SECONDS = Number(process.env.ASTRA_STT_CHUNK_SECONDS ?? "2.5
 
 const safeText = (text: string): string => text.replace(/\s+/g, " ").trim().slice(0, VOICE_TEXT_LIMIT);
 
+const commandExists = (binary: string): boolean => {
+  const probe = spawnSync("bash", ["-lc", `command -v ${binary}`], {stdio: "ignore"});
+  return probe.status === 0;
+};
+
 const runShell = async (command: string): Promise<void> =>
   new Promise((resolve, reject) => {
     const child = spawn(command, {shell: true, stdio: "ignore"});
@@ -30,9 +35,24 @@ const captureAudioChunk = async (seconds: number): Promise<string> => {
   let cmd = custom ?? "";
   if (!cmd) {
     if (process.platform === "darwin") {
-      cmd = `sox -q -d -r 16000 -c 1 -b 16 "${outPath}" trim 0 ${seconds}`;
+      // Prefer ffmpeg on macOS (works on Apple Silicon/Homebrew setups).
+      if (commandExists("ffmpeg")) {
+        cmd = `ffmpeg -hide_banner -loglevel error -f avfoundation -i ":0" -ar 16000 -ac 1 -t ${seconds} "${outPath}"`;
+      } else if (commandExists("rec")) {
+        cmd = `rec -q -r 16000 -c 1 "${outPath}" trim 0 ${seconds}`;
+      } else {
+        throw new Error(
+          "No macOS recorder found. Install ffmpeg (recommended) or sox (`rec`), or set ASTRA_STT_CAPTURE_COMMAND."
+        );
+      }
     } else if (process.platform === "linux") {
-      cmd = `arecord -q -f S16_LE -r 16000 -c 1 -d ${Math.ceil(seconds)} "${outPath}"`;
+      if (commandExists("arecord")) {
+        cmd = `arecord -q -f S16_LE -r 16000 -c 1 -d ${Math.ceil(seconds)} "${outPath}"`;
+      } else if (commandExists("ffmpeg")) {
+        cmd = `ffmpeg -hide_banner -loglevel error -f pulse -i default -ar 16000 -ac 1 -t ${seconds} "${outPath}"`;
+      } else {
+        throw new Error("No Linux recorder found. Install arecord/alsa-utils or ffmpeg, or set ASTRA_STT_CAPTURE_COMMAND.");
+      }
     } else {
       throw new Error("No default audio capture command for this platform. Set ASTRA_STT_CAPTURE_COMMAND.");
     }
@@ -135,6 +155,7 @@ export const startLiveTranscription = (handlers: {
   let running = true;
   let stopping = false;
   let transcript = "";
+  let consecutiveErrors = 0;
   let finishedResolve: (() => void) | null = null;
   const finished = new Promise<void>((resolve) => {
     finishedResolve = resolve;
@@ -146,12 +167,28 @@ export const startLiveTranscription = (handlers: {
       try {
         audioPath = await captureAudioChunk(DEFAULT_CHUNK_SECONDS);
         const piece = await transcribeAudioFile(audioPath);
+        consecutiveErrors = 0;
         if (piece) {
           transcript = transcript ? `${transcript} ${piece}` : piece;
           handlers.onPartial(transcript);
         }
       } catch (error) {
-        handlers.onError(error instanceof Error ? error : new Error(String(error)));
+        consecutiveErrors += 1;
+        const err = error instanceof Error ? error : new Error(String(error));
+        if (/Command failed \(127\)/.test(err.message)) {
+          handlers.onError(
+            new Error(
+              "Audio capture tool not found. Install ffmpeg/rec (macOS) or arecord/ffmpeg (Linux), or set ASTRA_STT_CAPTURE_COMMAND."
+            )
+          );
+          running = false;
+        } else {
+          handlers.onError(err);
+          // Stop error spam on persistent capture/transcription failures.
+          if (consecutiveErrors >= 2) {
+            running = false;
+          }
+        }
       } finally {
         if (audioPath) {
           await rm(audioPath, {force: true});

package/src/types/events.ts

@@ -2,6 +2,9 @@ export type AuthSession = {
   user_id: string;
   org_id: string;
   email?: string;
+  role?: string;
+  display_name?: string;
+  access_token?: string;
   [key: string]: unknown;
 };
 
@@ -13,14 +16,19 @@ export type ChatMessage = {
 export type AgentEvent =
   | {type: "text"; content?: string}
   | {type: "thinking"; content?: string}
-  | {type: "tool_start"; tool?: {name?: string}}
+  | {type: "tool_start"; tool?: {name?: string; id?: string; arguments?: Record<string, unknown>}}
+  | {type: "file_edit_start"; tool_id?: string; tool_name?: string; data?: {tool_id?: string; tool_name?: string}}
   | {
       type: "tool_result";
       success?: boolean;
       tool_name?: string;
+      result_type?: string;
+      tool_call_id?: string;
       data?: Record<string, unknown>;
       error?: string;
     }
+  | {type: "file_edit_path"; tool_id?: string; path?: string; is_create?: boolean; tool_name?: string; data?: {tool_id?: string; path?: string; is_create?: boolean; tool_name?: string}}
+  | {type: "file_edit_delta"; tool_id?: string; content?: string; data?: {tool_id?: string}}
   | {
       type: "run_in_terminal";
       terminal_id?: string;
@@ -30,4 +38,5 @@ export type AgentEvent =
     }
   | {type: "credits_update"; remaining?: number; cost?: number}
   | {type: "credits_exhausted"; message?: string}
-  | {type: "error"; error?: string; content?: string};
+  | {type: "error"; error?: string; content?: string}
+  | {type: string; [key: string]: unknown};