@astra-code/astra-ai 0.1.0 → 0.1.2

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/config.ts

@@ -2,7 +2,18 @@ import path from "node:path";
 import os from "node:os";
 import dotenv from "dotenv";
 
-dotenv.config({path: path.resolve(process.cwd(), ".env"), quiet: true});
+const USER_CONFIG_DIR = path.join(os.homedir(), ".astra-code");
+const USER_ENV_FILE = path.join(USER_CONFIG_DIR, ".env");
+const PROJECT_ENV_FILE = path.resolve(process.cwd(), ".env");
+
+// 1) Load user-level defaults from ~/.astra-code/.env
+dotenv.config({path: USER_ENV_FILE, quiet: true});
+
+// 2) Optionally load project-level .env (opt-in for trusted repos only)
+const allowProjectEnv = /^(1|true|yes|on)$/i.test(process.env.ASTRA_ALLOW_PROJECT_ENV ?? "");
+if (allowProjectEnv) {
+  dotenv.config({path: PROJECT_ENV_FILE, quiet: true});
+}
 
 export const APP_NAME = "astra-code";
 export const SESSION_DIR = path.join(os.homedir(), ".astra-code");

package/src/lib/voice.ts

@@ -3,6 +3,8 @@ import {randomUUID} from "crypto";
 import {basename, join} from "path";
 import {tmpdir} from "os";
 import {readFile, rm} from "fs/promises";
+import {getBackendUrl} from "./config.js";
+import {loadSession} from "./sessionStore.js";
 
 const VOICE_TEXT_LIMIT = 600;
 const DEFAULT_STT_MODEL = process.env.ASTRA_STT_MODEL?.trim() || "whisper-1";
@@ -10,6 +12,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 +37,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.");
     }
@@ -45,29 +67,26 @@ const captureAudioChunk = async (seconds: number): Promise<string> => {
 };
 
 const transcribeAudioFile = async (filePath: string): Promise<string> => {
-  const apiKey = process.env.ASTRA_OPENAI_API_KEY?.trim() || process.env.OPENAI_API_KEY?.trim();
-  if (!apiKey) {
-    throw new Error("Missing OPENAI_API_KEY (or ASTRA_OPENAI_API_KEY) for Whisper STT.");
-  }
-
   const bytes = await readFile(filePath);
   const file = new File([bytes], basename(filePath), {type: "audio/wav"});
+
+  // Backend proxy only: backend holds provider secrets.
+  const token = loadSession()?.access_token;
+  if (!token) {
+    throw new Error("Missing auth session for backend STT. Please sign in again.");
+  }
   const form = new FormData();
   form.append("file", file);
   form.append("model", DEFAULT_STT_MODEL);
-  form.append("response_format", "json");
-
-  const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+  const response = await fetch(`${getBackendUrl()}/api/agent/transcribe`, {
     method: "POST",
-    headers: {Authorization: `Bearer ${apiKey}`},
+    headers: {Authorization: `Bearer ${token}`},
     body: form
   });
-
   if (!response.ok) {
     const detail = (await response.text()).slice(0, 400);
-    throw new Error(`Whisper STT failed ${response.status}: ${detail}`);
+    throw new Error(`Backend transcription failed ${response.status}: ${detail}`);
   }
-
   const data = (await response.json()) as {text?: string};
   return String(data.text ?? "").trim();
 };
@@ -135,6 +154,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 +166,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};