indusagi-coding-agent 0.2.8 → 0.2.10

package/src/integrations/sarvam/attach.ts

@@ -0,0 +1,239 @@
+/**
+ * Attach Sarvam MCP tools to the coding agent via indusagi/sarvam-mcp.
+ */
+
+import { connectSarvamMcp } from "indusagi/sarvam-mcp";
+import { createMCPAgentToolFactory } from "indusagi/mcp";
+import type { SarvamAttachResult, SarvamHostConfig } from "./types.js";
+import { resolveSarvamConfig, redactApiKey, type ResolveSarvamOptions } from "./config.js";
+
+/** Live connection handle for /sarvam status and disconnect. */
+let live: {
+  id: string;
+  toolNames: readonly string[];
+  close: () => Promise<void>;
+  keyRedacted: string;
+  basePath?: string;
+} | null = null;
+
+let connecting = false;
+let cancelConnect = false;
+
+export function getLiveSarvam(): typeof live {
+  return live;
+}
+
+export function isSarvamConnecting(): boolean {
+  return connecting;
+}
+
+/**
+ * Convert a connected Sarvam MCP client into AgentTool[] using the same factory
+ * the coding agent uses for generic MCP servers.
+ */
+async function toolsFromConnection(
+  conn: Awaited<ReturnType<typeof connectSarvamMcp>>,
+): Promise<unknown[]> {
+  const tools: unknown[] = [];
+  const client = conn.client as {
+    listTools: () => Promise<
+      Array<{ name: string; description?: string; inputSchema: Record<string, unknown> }>
+    >;
+    serverName: string;
+    connected: boolean;
+    callTool: (name: string, args: Record<string, unknown>) => Promise<unknown>;
+  };
+
+  try {
+    const defs = await client.listTools();
+    for (const def of defs) {
+      const factory = createMCPAgentToolFactory(def, client as never);
+      tools.push(factory());
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[sarvam] listTools/factory failed: ${message}`);
+  }
+  return tools;
+}
+
+export interface AttachSarvamOptions {
+  closables?: Array<() => Promise<void>>;
+  onStatus?: (message: string) => void;
+}
+
+/**
+ * Connect to Sarvam MCP (spawns uvx sarvam-mcp) and return AgentTool-compatible tools.
+ */
+export async function attachSarvamTools(
+  config: SarvamHostConfig,
+  opts?: AttachSarvamOptions,
+): Promise<SarvamAttachResult> {
+  if (live) {
+    try {
+      await live.close();
+    } catch {
+      /* ignore */
+    }
+    live = null;
+  }
+
+  connecting = true;
+  cancelConnect = false;
+  opts?.onStatus?.(
+    "Spawning uvx sarvam-mcp… (first run may download the package, ~30–60s)",
+  );
+
+  try {
+    const conn = await connectSarvamMcp({
+      apiKey: config.apiKey,
+      id: config.id ?? "sarvam",
+      baseUrl: config.baseUrl,
+      basePath: config.basePath,
+      command: config.command,
+      args: config.args,
+      timeoutMs: 120_000,
+    });
+
+    if (cancelConnect) {
+      try {
+        await conn.close();
+      } catch {
+        /* ignore */
+      }
+      throw new Error("Sarvam connect cancelled (disconnect).");
+    }
+
+    const tools = await toolsFromConnection(conn);
+    const fromTools = tools
+      .map((t) => (t as { name?: string }).name)
+      .filter((n): n is string => typeof n === "string" && n.length > 0);
+    const toolNames =
+      fromTools.length > 0
+        ? fromTools
+        : conn.toolNames.length > 0
+          ? [...conn.toolNames]
+          : [];
+
+    const close = async () => {
+      try {
+        await conn.close();
+      } finally {
+        if (live?.id === (config.id ?? "sarvam")) live = null;
+      }
+    };
+
+    opts?.closables?.push(close);
+
+    const keyRedacted = config.apiKey ? redactApiKey(config.apiKey) : "(env)";
+
+    live = {
+      id: config.id ?? "sarvam",
+      toolNames,
+      close,
+      keyRedacted,
+      basePath: config.basePath,
+    };
+
+    return { tools, toolNames, id: config.id ?? "sarvam", close };
+  } finally {
+    connecting = false;
+  }
+}
+
+/**
+ * Session helper: resolve config and attach, or return [] if Sarvam is off.
+ * Soft-fails so missing uvx / bad key does not crash the coding agent.
+ */
+export async function loadSarvamAgentTools(opts: {
+  cwd: string;
+  closables?: Array<() => Promise<void>>;
+  sarvamKey?: string;
+  noSarvam?: boolean;
+  forceSarvam?: boolean;
+  basePath?: string;
+}): Promise<unknown[]> {
+  const resolveOpts: ResolveSarvamOptions = {
+    cwd: opts.cwd,
+    apiKey: opts.sarvamKey,
+    disabled: opts.noSarvam,
+    forceEnable: opts.forceSarvam,
+    basePath: opts.basePath,
+  };
+  const config = resolveSarvamConfig(resolveOpts);
+  if (!config) return [];
+
+  try {
+    const result = await attachSarvamTools(config, { closables: opts.closables });
+    return [...result.tools];
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[sarvam] failed to attach: ${message}`);
+    if (/uvx|ENOENT|spawn/i.test(message)) {
+      console.error(
+        "[sarvam] Install uv (provides uvx): https://docs.astral.sh/uv/  then re-run /sarvam-connect",
+      );
+    }
+    return [];
+  }
+}
+
+export async function disconnectLiveSarvam(): Promise<boolean> {
+  if (connecting) {
+    cancelConnect = true;
+  }
+  if (!live) {
+    return connecting;
+  }
+  try {
+    await live.close();
+  } catch {
+    /* ignore */
+  }
+  live = null;
+  return true;
+}
+
+export function sarvamStatusLines(): string {
+  if (connecting) {
+    return [
+      "Sarvam MCP: connecting… (spawning uvx sarvam-mcp)",
+      "First run may download the Python package (~30–60s).",
+      "Run /sarvam-disconnect to cancel.",
+    ].join("\n");
+  }
+  if (!live) {
+    return [
+      "Sarvam MCP: not connected.",
+      "Set SARVAM_API_KEY or run /sarvam-connect [key].",
+      "Requires uv/uvx: https://docs.astral.sh/uv/",
+      "Key: https://dashboard.sarvam.ai/key-management",
+      "",
+      "Commands: /sarvam-connect · /sarvam-disconnect · /sarvam-status · /sarvam-tools · /sarvam-help",
+    ].join("\n");
+  }
+  return [
+    `Sarvam MCP: connected (id=${live.id}).`,
+    `API key: ${live.keyRedacted}`,
+    live.basePath ? `Base path: ${live.basePath}` : "Base path: ~/Desktop (default)",
+    `Tools (${live.toolNames.length}):`,
+    ...live.toolNames.map((n) => `  • ${n}`),
+    "",
+    "Run /sarvam-disconnect to close the connection.",
+  ].join("\n");
+}
+
+export function sarvamConnectingText(): string {
+  return [
+    "Sarvam MCP — connecting",
+    "",
+    "Spawning: uvx sarvam-mcp",
+    "First run may download the package (30–60 seconds).",
+    "",
+    "Prerequisites:",
+    "  • uv installed → https://docs.astral.sh/uv/",
+    "  • SARVAM_API_KEY from https://dashboard.sarvam.ai/key-management",
+    "",
+    "Cancel: /sarvam-disconnect",
+  ].join("\n");
+}

package/src/integrations/sarvam/config.ts

@@ -0,0 +1,156 @@
+/**
+ * Resolve Sarvam MCP config from flags / env / config files.
+ *
+ * Precedence (high → low):
+ *   1. explicit apiKey argument
+ *   2. --sarvam-key
+ *   3. SARVAM_API_KEY env
+ *   4. project .indusagi/sarvam.json (enabled + basePath; key still from env preferred)
+ *   5. profile ~/.indusagi/agent/sarvam.json
+ *
+ * Non-secret fields (basePath, baseUrl, enabled) come from files; API keys
+ * prefer env / CLI to avoid committing secrets.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import type { SarvamHostConfig } from "./types.js";
+
+const ENV_KEY = "SARVAM_API_KEY";
+const ENV_DISABLE = "SARVAM_DISABLED";
+const ENV_BASE_URL = "SARVAM_API_BASE_URL";
+const ENV_BASE_PATH = "SARVAM_MCP_BASE_PATH";
+
+function readJsonFile(path: string): Record<string, unknown> | undefined {
+  try {
+    if (!existsSync(path)) return undefined;
+    const raw = readFileSync(path, "utf8");
+    const parsed = JSON.parse(raw) as unknown;
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return undefined;
+    }
+    return parsed as Record<string, unknown>;
+  } catch {
+    return undefined;
+  }
+}
+
+function configFromRecord(rec: Record<string, unknown> | undefined): SarvamHostConfig | undefined {
+  if (!rec) return undefined;
+  const enabled = rec.enabled === false ? false : true;
+  const id = typeof rec.id === "string" && rec.id.trim() ? rec.id.trim() : "sarvam";
+  const apiKey = typeof rec.apiKey === "string" ? rec.apiKey.trim() : undefined;
+  const baseUrl = typeof rec.baseUrl === "string" ? rec.baseUrl.trim() : undefined;
+  const basePath = typeof rec.basePath === "string" ? rec.basePath.trim() : undefined;
+  const command = typeof rec.command === "string" ? rec.command.trim() : undefined;
+  // File alone without key is still useful when env has SARVAM_API_KEY
+  return {
+    id,
+    enabled,
+    ...(apiKey ? { apiKey } : {}),
+    ...(baseUrl ? { baseUrl } : {}),
+    ...(basePath ? { basePath } : {}),
+    ...(command ? { command } : {}),
+  };
+}
+
+/** Profile path: ~/.indusagi/agent/sarvam.json */
+export function profileSarvamPath(home = homedir()): string {
+  return join(home, ".indusagi", "agent", "sarvam.json");
+}
+
+/** Project path: <cwd>/.indusagi/sarvam.json */
+export function projectSarvamPath(cwd: string): string {
+  return join(cwd, ".indusagi", "sarvam.json");
+}
+
+/**
+ * Save non-secret Sarvam prefs. Does not write apiKey unless explicitly present
+ * on config (prefer env for secrets).
+ */
+export function saveSarvamConfig(
+  config: SarvamHostConfig,
+  where: "profile" | "project" = "profile",
+  cwd = process.cwd(),
+): string {
+  const path = where === "project" ? projectSarvamPath(cwd) : profileSarvamPath();
+  mkdirSync(dirname(path), { recursive: true });
+  const body: Record<string, unknown> = {
+    id: config.id ?? "sarvam",
+    enabled: config.enabled !== false,
+  };
+  if (config.basePath) body.basePath = config.basePath;
+  if (config.baseUrl) body.baseUrl = config.baseUrl;
+  if (config.command) body.command = config.command;
+  // Only persist key if caller intentionally set it (e.g. interactive connect with key arg).
+  if (config.apiKey) body.apiKey = config.apiKey;
+  writeFileSync(path, JSON.stringify(body, null, 2) + "\n", "utf8");
+  return path;
+}
+
+export interface ResolveSarvamOptions {
+  /** Explicit API key (e.g. from --sarvam-key). */
+  apiKey?: string;
+  /** Force disable (--no-sarvam). */
+  disabled?: boolean;
+  /** Force enable when key present (--sarvam). */
+  forceEnable?: boolean;
+  basePath?: string;
+  baseUrl?: string;
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  /** Override home for profile path (tests). */
+  home?: string;
+}
+
+/**
+ * Resolve effective Sarvam config or undefined if Sarvam should not attach.
+ * Requires a resolvable API key (arg, env, or file).
+ */
+export function resolveSarvamConfig(opts: ResolveSarvamOptions = {}): SarvamHostConfig | undefined {
+  const env = opts.env ?? process.env;
+  const cwd = opts.cwd ?? process.cwd();
+
+  if (opts.disabled || env[ENV_DISABLE] === "1" || env[ENV_DISABLE] === "true") {
+    return undefined;
+  }
+
+  const fromArgKey = opts.apiKey?.trim();
+  const fromEnvKey = env[ENV_KEY]?.trim();
+  const fromProject = configFromRecord(readJsonFile(projectSarvamPath(cwd)));
+  const fromProfile = configFromRecord(
+    readJsonFile(profileSarvamPath(opts.home ?? homedir())),
+  );
+
+  const fileBase = fromProject ?? fromProfile;
+  const apiKey = fromArgKey || fromEnvKey || fileBase?.apiKey;
+  if (!apiKey) {
+    // No key → only attach if forceEnable is false and we still want to signal "off"
+    return undefined;
+  }
+
+  if (fileBase?.enabled === false && !opts.forceEnable) {
+    return undefined;
+  }
+
+  return {
+    apiKey,
+    id: fileBase?.id ?? "sarvam",
+    enabled: true,
+    baseUrl:
+      opts.baseUrl?.trim() ||
+      env[ENV_BASE_URL]?.trim() ||
+      fileBase?.baseUrl,
+    basePath:
+      opts.basePath?.trim() ||
+      env[ENV_BASE_PATH]?.trim() ||
+      fileBase?.basePath,
+    command: fileBase?.command,
+  };
+}
+
+export function redactApiKey(key: string): string {
+  if (key.length <= 8) return "****";
+  return `${key.slice(0, 4)}…${key.slice(-4)}`;
+}

package/src/integrations/sarvam/index.ts

@@ -0,0 +1,25 @@
+/**
+ * Sarvam integration for indusagi-coding-agent.
+ *
+ * Consumes `indusagi/sarvam-mcp` from the local framework package.
+ */
+
+export type { SarvamHostConfig, SarvamAttachResult } from "./types.js";
+export {
+  resolveSarvamConfig,
+  saveSarvamConfig,
+  profileSarvamPath,
+  projectSarvamPath,
+  redactApiKey,
+} from "./config.js";
+export type { ResolveSarvamOptions } from "./config.js";
+export {
+  attachSarvamTools,
+  loadSarvamAgentTools,
+  disconnectLiveSarvam,
+  getLiveSarvam,
+  sarvamStatusLines,
+  sarvamConnectingText,
+  isSarvamConnecting,
+} from "./attach.js";
+export type { AttachSarvamOptions } from "./attach.js";

package/src/integrations/sarvam/sarvam.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect } from "vitest";
+import { resolveSarvamConfig, redactApiKey } from "./config.js";
+
+describe("resolveSarvamConfig", () => {
+  const isolatedHome = "/tmp/indusagi-sarvam-test-home-empty";
+
+  it("returns undefined when nothing is configured", () => {
+    expect(
+      resolveSarvamConfig({ env: {}, cwd: "/tmp", home: isolatedHome, disabled: false }),
+    ).toBeUndefined();
+  });
+
+  it("prefers explicit key over env", () => {
+    const cfg = resolveSarvamConfig({
+      apiKey: "key-from-arg",
+      env: { SARVAM_API_KEY: "key-from-env" },
+      cwd: "/tmp",
+      home: isolatedHome,
+    });
+    expect(cfg?.apiKey).toBe("key-from-arg");
+  });
+
+  it("honors SARVAM_API_KEY", () => {
+    const cfg = resolveSarvamConfig({
+      env: { SARVAM_API_KEY: "sk-test-123" },
+      cwd: "/tmp",
+      home: isolatedHome,
+    });
+    expect(cfg?.apiKey).toBe("sk-test-123");
+    expect(cfg?.id).toBe("sarvam");
+  });
+
+  it("disabled wins", () => {
+    const cfg = resolveSarvamConfig({
+      apiKey: "sk-test",
+      disabled: true,
+      cwd: "/tmp",
+      home: isolatedHome,
+    });
+    expect(cfg).toBeUndefined();
+  });
+
+  it("honors basePath from options", () => {
+    const cfg = resolveSarvamConfig({
+      apiKey: "sk-test",
+      basePath: "/tmp/sarvam-out",
+      cwd: "/tmp",
+      home: isolatedHome,
+    });
+    expect(cfg?.basePath).toBe("/tmp/sarvam-out");
+  });
+});
+
+describe("redactApiKey", () => {
+  it("masks middle", () => {
+    const r = redactApiKey("abcdefghijklmnop");
+    expect(r).toContain("…");
+    expect(r).not.toBe("abcdefghijklmnop");
+  });
+});

package/src/integrations/sarvam/types.ts

@@ -0,0 +1,27 @@
+/**
+ * Sarvam host config for the coding agent.
+ */
+
+export interface SarvamHostConfig {
+  /** Sarvam dashboard API key. Optional if SARVAM_API_KEY is in env. */
+  readonly apiKey?: string;
+  /** Tool prefix / id (default: sarvam). */
+  readonly id?: string;
+  /** When false, skip attach even if key is set. */
+  readonly enabled?: boolean;
+  /** Override Sarvam API base URL. */
+  readonly baseUrl?: string;
+  /** Where TTS/docs files land (default ~/Desktop). */
+  readonly basePath?: string;
+  /** Subprocess command (default: uvx). */
+  readonly command?: string;
+  /** Subprocess args (default: ["sarvam-mcp"]). */
+  readonly args?: readonly string[];
+}
+
+export interface SarvamAttachResult {
+  readonly tools: readonly unknown[];
+  readonly toolNames: readonly string[];
+  readonly id: string;
+  close(): Promise<void>;
+}