indusagi-coding-agent 0.2.8 → 0.2.9

package/src/integrations/zoho/attach.ts

@@ -0,0 +1,342 @@
+/**
+ * Attach Zoho MCP tools to the coding agent via indusagi/zoho.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { connectZohoMcp } from "indusagi/zoho";
+import { createMCPAgentToolFactory } from "indusagi/mcp";
+import type { ZohoAttachResult, ZohoHostConfig } from "./types.js";
+import { resolveZohoConfig, type ResolveZohoOptions } from "./config.js";
+
+/** Live connection handle for /zoho status and disconnect. */
+let live: {
+  id: string;
+  toolNames: readonly string[];
+  close: () => Promise<void>;
+  urlRedacted: string;
+} | null = null;
+
+/** In-flight connect (so disconnect / UI can track). */
+let connecting = false;
+/** If true, tear down as soon as connect resolves. */
+let cancelConnect = false;
+/** Last OAuth authorize URL shown to the user (for overlay / status). */
+let lastAuthUrl: string | undefined;
+
+export function getLiveZoho(): typeof live {
+  return live;
+}
+
+export function isZohoConnecting(): boolean {
+  return connecting;
+}
+
+export function getLastZohoAuthUrl(): string | undefined {
+  return lastAuthUrl;
+}
+
+/** Default credentials path used by the framework OAuth provider. */
+function zohoTokenPath(id = "zoho"): string {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? homedir();
+  const dir =
+    xdg && xdg.length > 0
+      ? join(xdg, "indusagi", "credentials", "mcp")
+      : join(home, ".config", "indusagi", "credentials", "mcp");
+  return join(dir, `${id.replace(/[^a-zA-Z0-9._-]/g, "-")}.json`);
+}
+
+/**
+ * True when a usable access_token is already on disk (skip browser at boot).
+ */
+export function hasUsableZohoTokens(id = "zoho"): boolean {
+  const path = zohoTokenPath(id);
+  try {
+    if (!existsSync(path)) return false;
+    const raw = readFileSync(path, "utf8");
+    const parsed = JSON.parse(raw) as { tokens?: { access_token?: string } };
+    return typeof parsed?.tokens?.access_token === "string" && parsed.tokens.access_token.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function extractAuthUrl(message: string): string | undefined {
+  // Framework logs: "oauth: open this URL…\n  https://…"
+  const multi = message.match(/https?:\/\/[^\s]+/g);
+  if (!multi || multi.length === 0) return undefined;
+  // Prefer the authorize URL (not the local callback).
+  const auth = multi.find((u) => !u.includes("127.0.0.1") && !u.includes("localhost"));
+  return auth ?? multi[0];
+}
+
+/**
+ * Convert a connected Zoho MCP client into AgentTool[] using the same factory
+ * the coding agent uses for generic MCP servers (`createMCPAgentToolFactory`).
+ * Tool names become `{serverName}_{mcpToolName}` (e.g. zoho_getLeadsRecords).
+ */
+async function toolsFromConnection(
+  conn: Awaited<ReturnType<typeof connectZohoMcp>>,
+): 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(`[zoho] listTools/factory failed: ${message}`);
+  }
+  return tools;
+}
+
+export interface AttachZohoOptions {
+  closables?: Array<() => Promise<void>>;
+  /** Always try to open the system browser (default true for interactive). */
+  openBrowser?: boolean;
+  /** Called when framework logs OAuth progress (includes authorize URL). */
+  onAuthMessage?: (message: string) => void;
+  /** Called when an authorize URL is detected. */
+  onAuthUrl?: (url: string) => void;
+}
+
+/**
+ * Connect to Zoho MCP and return AgentTool-compatible tools.
+ * Registers close on opts.closables when provided.
+ */
+export async function attachZohoTools(
+  config: ZohoHostConfig,
+  opts?: AttachZohoOptions,
+): Promise<ZohoAttachResult> {
+  // Tear down previous live connection if any
+  if (live) {
+    try {
+      await live.close();
+    } catch {
+      /* ignore */
+    }
+    live = null;
+  }
+
+  connecting = true;
+  cancelConnect = false;
+  lastAuthUrl = undefined;
+
+  const onAuthMessage = opts?.onAuthMessage;
+  const onAuthUrl = opts?.onAuthUrl;
+  const openBrowser = opts?.openBrowser !== false;
+
+  const handleLog = (msg: string) => {
+    try {
+      onAuthMessage?.(msg);
+    } catch {
+      /* ignore UI errors */
+    }
+    const url = extractAuthUrl(msg);
+    if (url) {
+      lastAuthUrl = url;
+      try {
+        onAuthUrl?.(url);
+      } catch {
+        /* ignore */
+      }
+    }
+  };
+
+  try {
+    const conn = await connectZohoMcp({
+      url: config.url,
+      id: config.id ?? "zoho",
+      auth: config.auth ?? "auto",
+      timeoutMs: 60_000,
+      // Force browser open for interactive connect (don't gate only on isTTY).
+      openBrowser,
+      logger: {
+        debug: (msg) => handleLog(msg),
+        error: (msg, err) => {
+          const detail = err instanceof Error ? err.message : err !== undefined ? String(err) : "";
+          handleLog(detail ? `${msg}: ${detail}` : msg);
+          console.error(`[zoho error] ${msg}${detail ? `: ${detail}` : ""}`);
+        },
+      },
+    });
+
+    if (cancelConnect) {
+      try {
+        await conn.close();
+      } catch {
+        /* ignore */
+      }
+      throw new Error("Zoho connect cancelled (disconnect).");
+    }
+
+    const tools = await toolsFromConnection(conn);
+    // Prefer names the agent actually calls (createMCPAgentToolFactory),
+    // fall back to framework-prefixed names from connectZohoMcp.
+    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 ?? "zoho")) live = null;
+      }
+    };
+
+    opts?.closables?.push(close);
+
+    let urlRedacted = config.url;
+    try {
+      const u = new URL(config.url);
+      urlRedacted = `${u.protocol}//${u.host}/…`;
+    } catch {
+      urlRedacted = "(url)";
+    }
+
+    live = {
+      id: config.id ?? "zoho",
+      toolNames,
+      close,
+      urlRedacted,
+    };
+
+    return { tools, toolNames, id: config.id ?? "zoho", close };
+  } finally {
+    connecting = false;
+  }
+}
+
+/**
+ * Session helper: resolve config and attach, or return [] if Zoho is off.
+ *
+ * Boot-safe: if there is no usable OAuth token yet, skip auto-attach so we
+ * never hang the CLI for 5 minutes waiting for a browser. Interactive
+ * `/zoho connect` still runs the full OAuth flow.
+ */
+export async function loadZohoAgentTools(opts: {
+  cwd: string;
+  closables?: Array<() => Promise<void>>;
+  /** From invocation flags */
+  zohoUrl?: string;
+  noZoho?: boolean;
+  forceZoho?: boolean;
+  /** Allow browser OAuth during load (default false — use /zoho connect). */
+  allowBrowserOAuth?: boolean;
+}): Promise<unknown[]> {
+  const resolveOpts: ResolveZohoOptions = {
+    cwd: opts.cwd,
+    url: opts.zohoUrl,
+    disabled: opts.noZoho,
+    forceEnable: opts.forceZoho,
+  };
+  const config = resolveZohoConfig(resolveOpts);
+  if (!config) return [];
+
+  const allowBrowser = opts.allowBrowserOAuth === true;
+  if (!allowBrowser && !hasUsableZohoTokens(config.id ?? "zoho")) {
+    // Soft skip: user has URL configured but has not completed OAuth yet.
+    console.error(
+      "[zoho] URL configured but no OAuth tokens yet — run /zoho-connect to authorize in the browser.",
+    );
+    return [];
+  }
+
+  try {
+    const result = await attachZohoTools(config, {
+      closables: opts.closables,
+      openBrowser: allowBrowser,
+    });
+    return [...result.tools];
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[zoho] failed to attach: ${message}`);
+    return [];
+  }
+}
+
+export async function disconnectLiveZoho(): Promise<boolean> {
+  // Cancel in-flight connect if any
+  if (connecting) {
+    cancelConnect = true;
+  }
+  if (!live) {
+    return connecting; // "was connecting" still counts as handled
+  }
+  try {
+    await live.close();
+  } catch {
+    /* ignore */
+  }
+  live = null;
+  return true;
+}
+
+export function zohoStatusLines(): string {
+  if (connecting) {
+    const lines = [
+      "Zoho MCP: connecting… (OAuth may open your browser)",
+      "Complete login in the browser, then wait for tools to load.",
+      "Run /zoho-disconnect to cancel.",
+    ];
+    if (lastAuthUrl) {
+      lines.push("", "If the browser did not open, visit this URL:", `  ${lastAuthUrl}`);
+    }
+    return lines.join("\n");
+  }
+  if (!live) {
+    return [
+      "Zoho MCP: not connected.",
+      "Set ZOHO_MCP_URL or run /zoho-connect <url>.",
+      "Tokens (after OAuth): ~/.config/indusagi/credentials/mcp/zoho.json",
+      "",
+      "Commands: /zoho-connect · /zoho-disconnect · /zoho-status · /zoho-tools · /zoho-help",
+    ].join("\n");
+  }
+  return [
+    `Zoho MCP: connected (id=${live.id}).`,
+    `Endpoint: ${live.urlRedacted}`,
+    `Tools (${live.toolNames.length}):`,
+    ...live.toolNames.map((n) => `  • ${n}`),
+    "",
+    "Run /zoho-disconnect to close the connection.",
+  ].join("\n");
+}
+
+/** Overlay text while waiting for browser OAuth. */
+export function zohoOAuthPendingText(authUrl?: string): string {
+  const url = authUrl ?? lastAuthUrl;
+  return [
+    "Zoho OAuth — authorize in your browser",
+    "",
+    "1. A browser window should open automatically.",
+    "2. Sign in to Zoho and approve access.",
+    "3. Return here — tools load when the callback succeeds.",
+    "",
+    url
+      ? `Open this URL if the browser did not open:\n\n  ${url}`
+      : "Waiting for authorize URL from Zoho…",
+    "",
+    "Timeout: 5 minutes.  ·  Cancel: /zoho-disconnect",
+  ].join("\n");
+}

package/src/integrations/zoho/config.ts

@@ -0,0 +1,125 @@
+/**
+ * Resolve Zoho MCP URL from flags / env / config files.
+ *
+ * Precedence (high → low):
+ *   1. explicit url argument
+ *   2. --zoho-url / process flags
+ *   3. ZOHO_MCP_URL env
+ *   4. project .indusagi/zoho.json
+ *   5. profile ~/.indusagi/agent/zoho.json
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import type { ZohoHostConfig } from "./types.js";
+
+const ENV_URL = "ZOHO_MCP_URL";
+const ENV_DISABLE = "ZOHO_DISABLED";
+
+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): ZohoHostConfig | undefined {
+  if (!rec) return undefined;
+  const url = typeof rec.url === "string" ? rec.url.trim() : "";
+  if (!url) return undefined;
+  const enabled = rec.enabled === false ? false : true;
+  const id = typeof rec.id === "string" && rec.id.trim() ? rec.id.trim() : "zoho";
+  const auth =
+    rec.auth === "none" || rec.auth === "oauth" || rec.auth === "auto"
+      ? rec.auth
+      : "auto";
+  return { url, id, enabled, auth };
+}
+
+/** Profile path: ~/.indusagi/agent/zoho.json */
+export function profileZohoPath(home = homedir()): string {
+  return join(home, ".indusagi", "agent", "zoho.json");
+}
+
+/** Project path: <cwd>/.indusagi/zoho.json */
+export function projectZohoPath(cwd: string): string {
+  return join(cwd, ".indusagi", "zoho.json");
+}
+
+export function saveZohoConfig(
+  config: ZohoHostConfig,
+  where: "profile" | "project" = "profile",
+  cwd = process.cwd(),
+): string {
+  const path = where === "project" ? projectZohoPath(cwd) : profileZohoPath();
+  mkdirSync(dirname(path), { recursive: true });
+  const body = {
+    url: config.url,
+    id: config.id ?? "zoho",
+    enabled: config.enabled !== false,
+    auth: config.auth ?? "auto",
+  };
+  writeFileSync(path, JSON.stringify(body, null, 2) + "\n", "utf8");
+  return path;
+}
+
+export interface ResolveZohoOptions {
+  /** Explicit URL (e.g. from --zoho-url). */
+  url?: string;
+  /** Force disable (--no-zoho). */
+  disabled?: boolean;
+  /** Force enable when URL present (--zoho). */
+  forceEnable?: boolean;
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  /** Override home for profile path (tests). */
+  home?: string;
+}
+
+/**
+ * Resolve effective Zoho config or undefined if Zoho should not attach.
+ */
+export function resolveZohoConfig(opts: ResolveZohoOptions = {}): ZohoHostConfig | 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 fromArg = opts.url?.trim();
+  const fromEnv = env[ENV_URL]?.trim();
+  const fromProject = configFromRecord(readJsonFile(projectZohoPath(cwd)));
+  const fromProfile = configFromRecord(
+    readJsonFile(profileZohoPath(opts.home ?? homedir())),
+  );
+  const base =
+    (fromArg ? { url: fromArg, id: "zoho", enabled: true, auth: "auto" as const } : undefined) ??
+    (fromEnv ? { url: fromEnv, id: "zoho", enabled: true, auth: "auto" as const } : undefined) ??
+    fromProject ??
+    fromProfile;
+
+  if (!base) return undefined;
+  if (base.enabled === false && !opts.forceEnable) return undefined;
+  return {
+    ...base,
+    enabled: true,
+  };
+}
+
+export function redactUrl(url: string): string {
+  try {
+    const u = new URL(url);
+    return `${u.protocol}//${u.host}${u.pathname.slice(0, 24)}…`;
+  } catch {
+    return "(invalid url)";
+  }
+}

package/src/integrations/zoho/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Zoho integration for indusagi-coding-agent.
+ *
+ * Consumes `indusagi/zoho` from the local framework package.
+ */
+
+export type { ZohoHostConfig, ZohoAttachResult } from "./types.js";
+export {
+  resolveZohoConfig,
+  saveZohoConfig,
+  profileZohoPath,
+  projectZohoPath,
+  redactUrl,
+} from "./config.js";
+export type { ResolveZohoOptions } from "./config.js";
+export {
+  attachZohoTools,
+  loadZohoAgentTools,
+  disconnectLiveZoho,
+  getLiveZoho,
+  zohoStatusLines,
+  zohoOAuthPendingText,
+  isZohoConnecting,
+  getLastZohoAuthUrl,
+  hasUsableZohoTokens,
+} from "./attach.js";
+export type { AttachZohoOptions } from "./attach.js";

package/src/integrations/zoho/types.ts

@@ -0,0 +1,21 @@
+/**
+ * Zoho host config for the coding agent.
+ */
+
+export interface ZohoHostConfig {
+  /** Zoho MCP server URL from the Connect tab. */
+  readonly url: string;
+  /** Tool prefix / credential id (default: zoho). */
+  readonly id?: string;
+  /** When false, skip attach even if URL is set. */
+  readonly enabled?: boolean;
+  /** Auth mode for connectZohoMcp (default: auto). */
+  readonly auth?: "auto" | "oauth" | "none";
+}
+
+export interface ZohoAttachResult {
+  readonly tools: readonly unknown[];
+  readonly toolNames: readonly string[];
+  readonly id: string;
+  close(): Promise<void>;
+}

package/src/integrations/zoho/zoho.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from "vitest";
+import { resolveZohoConfig, redactUrl } from "./config.js";
+
+describe("resolveZohoConfig", () => {
+  const isolatedHome = "/tmp/indusagi-zoho-test-home-empty";
+
+  it("returns undefined when nothing is configured", () => {
+    expect(
+      resolveZohoConfig({ env: {}, cwd: "/tmp", home: isolatedHome, disabled: false }),
+    ).toBeUndefined();
+  });
+
+  it("prefers explicit url over env", () => {
+    const cfg = resolveZohoConfig({
+      url: "https://mcp.example/a",
+      env: { ZOHO_MCP_URL: "https://mcp.example/b" },
+      cwd: "/tmp",
+      home: isolatedHome,
+    });
+    expect(cfg?.url).toBe("https://mcp.example/a");
+  });
+
+  it("honors ZOHO_MCP_URL", () => {
+    const cfg = resolveZohoConfig({
+      env: { ZOHO_MCP_URL: "https://mcp.zoho.example/x" },
+      cwd: "/tmp",
+      home: isolatedHome,
+    });
+    expect(cfg?.url).toBe("https://mcp.zoho.example/x");
+    expect(cfg?.id).toBe("zoho");
+  });
+
+  it("disabled wins", () => {
+    const cfg = resolveZohoConfig({
+      url: "https://mcp.example/a",
+      disabled: true,
+      cwd: "/tmp",
+      home: isolatedHome,
+    });
+    expect(cfg).toBeUndefined();
+  });
+});
+
+describe("redactUrl", () => {
+  it("keeps host", () => {
+    const r = redactUrl("https://mcp.zoho.in/secret/path/more");
+    expect(r).toContain("mcp.zoho.in");
+    expect(r).toContain("…");
+  });
+});

package/src/kit/clipboard-image.ts

@@ -0,0 +1,107 @@
+/**
+ * Clipboard-image kit — pull a raster image off the OS clipboard and stage it
+ * on disk as a temp PNG, returning the path the composer can splice into a
+ * prompt.
+ */
+import { spawnSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const READ_TIMEOUT_MS = 3000;
+const MAX_BUFFER_BYTES = 50 * 1024 * 1024;
+
+export interface ClipboardImageOptions {
+  readonly platform?: NodeJS.Platform;
+  readonly env?: NodeJS.ProcessEnv;
+  readonly dir?: string;
+}
+
+function captureStdout(command: string, args: string[]): Buffer | null {
+  const result = spawnSync(command, [...args], {
+    timeout: READ_TIMEOUT_MS,
+    maxBuffer: MAX_BUFFER_BYTES,
+  });
+  if (result.error || result.status !== 0) return null;
+  const out = result.stdout;
+  if (!Buffer.isBuffer(out) || out.length === 0) return null;
+  return out;
+}
+
+function captureViaOsascript(): Buffer | null {
+  const result = spawnSync(
+    "osascript",
+    [
+      "-e",
+      "try",
+      "-e",
+      "set png to (the clipboard as \xABclass PNGf\xBB)",
+      "-e",
+      'set fp to (path to temporary items as string) & "indus-clip.png"',
+      "-e",
+      "set fh to open for access file fp with write permission",
+      "-e",
+      "set eof fh to 0",
+      "-e",
+      "write png to fh",
+      "-e",
+      "close access fh",
+      "-e",
+      "POSIX path of fp",
+      "-e",
+      "on error",
+      "-e",
+      'return ""',
+      "-e",
+      "end try",
+    ],
+    { timeout: READ_TIMEOUT_MS, encoding: "utf8" },
+  );
+  if (result.error || result.status !== 0) return null;
+  const path = String(result.stdout ?? "").trim();
+  if (path.length === 0) return null;
+  try {
+    const bytes = readFileSync(path);
+    return bytes.length > 0 ? bytes : null;
+  } catch {
+    return null;
+  }
+}
+
+function readClipboardBytes(platform: NodeJS.Platform, env: NodeJS.ProcessEnv): Buffer | null {
+  if (platform === "darwin") {
+    return captureStdout("pngpaste", ["-"]) ?? captureViaOsascript();
+  }
+  if (platform === "linux") {
+    const wayland =
+      Boolean(env.WAYLAND_DISPLAY) || env.XDG_SESSION_TYPE === "wayland";
+    if (wayland) {
+      const fromWayland = captureStdout("wl-paste", [
+        "--type",
+        "image/png",
+        "--no-newline",
+      ]);
+      if (fromWayland) return fromWayland;
+    }
+    return captureStdout("xclip", ["-selection", "clipboard", "-t", "image/png", "-o"]);
+  }
+  return null;
+}
+
+export function readClipboardImage(options: ClipboardImageOptions = {}): string | null {
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const bytes = readClipboardBytes(platform, env);
+  if (bytes === null) return null;
+  const dir = options.dir ?? tmpdir();
+  const name = `indus-clipboard-${Date.now().toString(36)}-${Math.random()
+    .toString(36)
+    .slice(2, 8)}.png`;
+  const path = join(dir, name);
+  try {
+    writeFileSync(path, bytes);
+    return path;
+  } catch {
+    return null;
+  }
+}