remoteclaw 0.0.0 → 0.1.0-next.2abd2fa

package/extensions/zalouser/src/tool.ts

@@ -0,0 +1,166 @@
+import { Type } from "@sinclair/typebox";
+import { runZca, parseJsonOutput } from "./zca.js";
+
+const ACTIONS = ["send", "image", "link", "friends", "groups", "me", "status"] as const;
+
+type AgentToolResult = {
+  content: Array<{ type: string; text: string }>;
+  details?: unknown;
+};
+
+function stringEnum<T extends readonly string[]>(
+  values: T,
+  options: { description?: string } = {},
+) {
+  return Type.Unsafe<T[number]>({
+    type: "string",
+    enum: [...values],
+    ...options,
+  });
+}
+
+// Tool schema - avoiding Type.Union per tool schema guardrails
+export const ZalouserToolSchema = Type.Object(
+  {
+    action: stringEnum(ACTIONS, { description: `Action to perform: ${ACTIONS.join(", ")}` }),
+    threadId: Type.Optional(Type.String({ description: "Thread ID for messaging" })),
+    message: Type.Optional(Type.String({ description: "Message text" })),
+    isGroup: Type.Optional(Type.Boolean({ description: "Is group chat" })),
+    profile: Type.Optional(Type.String({ description: "Profile name" })),
+    query: Type.Optional(Type.String({ description: "Search query" })),
+    url: Type.Optional(Type.String({ description: "URL for media/link" })),
+  },
+  { additionalProperties: false },
+);
+
+type ToolParams = {
+  action: (typeof ACTIONS)[number];
+  threadId?: string;
+  message?: string;
+  isGroup?: boolean;
+  profile?: string;
+  query?: string;
+  url?: string;
+};
+
+function json(payload: unknown): AgentToolResult {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    details: payload,
+  };
+}
+
+export async function executeZalouserTool(
+  _toolCallId: string,
+  params: ToolParams,
+  _signal?: AbortSignal,
+  _onUpdate?: unknown,
+): Promise<AgentToolResult> {
+  try {
+    switch (params.action) {
+      case "send": {
+        if (!params.threadId || !params.message) {
+          throw new Error("threadId and message required for send action");
+        }
+        const args = ["msg", "send", params.threadId, params.message];
+        if (params.isGroup) {
+          args.push("-g");
+        }
+        const result = await runZca(args, { profile: params.profile });
+        if (!result.ok) {
+          throw new Error(result.stderr || "Failed to send message");
+        }
+        return json({ success: true, output: result.stdout });
+      }
+
+      case "image": {
+        if (!params.threadId) {
+          throw new Error("threadId required for image action");
+        }
+        if (!params.url) {
+          throw new Error("url required for image action");
+        }
+        const args = ["msg", "image", params.threadId, "-u", params.url];
+        if (params.message) {
+          args.push("-m", params.message);
+        }
+        if (params.isGroup) {
+          args.push("-g");
+        }
+        const result = await runZca(args, { profile: params.profile });
+        if (!result.ok) {
+          throw new Error(result.stderr || "Failed to send image");
+        }
+        return json({ success: true, output: result.stdout });
+      }
+
+      case "link": {
+        if (!params.threadId || !params.url) {
+          throw new Error("threadId and url required for link action");
+        }
+        const args = ["msg", "link", params.threadId, params.url];
+        if (params.isGroup) {
+          args.push("-g");
+        }
+        const result = await runZca(args, { profile: params.profile });
+        if (!result.ok) {
+          throw new Error(result.stderr || "Failed to send link");
+        }
+        return json({ success: true, output: result.stdout });
+      }
+
+      case "friends": {
+        const args = params.query ? ["friend", "find", params.query] : ["friend", "list", "-j"];
+        const result = await runZca(args, { profile: params.profile });
+        if (!result.ok) {
+          throw new Error(result.stderr || "Failed to get friends");
+        }
+        const parsed = parseJsonOutput(result.stdout);
+        return json(parsed ?? { raw: result.stdout });
+      }
+
+      case "groups": {
+        const result = await runZca(["group", "list", "-j"], {
+          profile: params.profile,
+        });
+        if (!result.ok) {
+          throw new Error(result.stderr || "Failed to get groups");
+        }
+        const parsed = parseJsonOutput(result.stdout);
+        return json(parsed ?? { raw: result.stdout });
+      }
+
+      case "me": {
+        const result = await runZca(["me", "info", "-j"], {
+          profile: params.profile,
+        });
+        if (!result.ok) {
+          throw new Error(result.stderr || "Failed to get profile");
+        }
+        const parsed = parseJsonOutput(result.stdout);
+        return json(parsed ?? { raw: result.stdout });
+      }
+
+      case "status": {
+        const result = await runZca(["auth", "status"], {
+          profile: params.profile,
+        });
+        return json({
+          authenticated: result.ok,
+          output: result.stdout || result.stderr,
+        });
+      }
+
+      default: {
+        params.action satisfies never;
+        throw new Error(
+          `Unknown action: ${String(params.action)}. Valid actions: send, image, link, friends, groups, me, status`,
+        );
+      }
+    }
+  } catch (err) {
+    return json({
+      error: err instanceof Error ? err.message : String(err),
+    });
+  }
+}

package/extensions/zalouser/src/types.ts

@@ -0,0 +1,105 @@
+// zca-cli wrapper types
+export type ZcaRunOptions = {
+  profile?: string;
+  cwd?: string;
+  timeout?: number;
+};
+
+export type ZcaResult = {
+  ok: boolean;
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+};
+
+export type ZcaProfile = {
+  name: string;
+  label?: string;
+  isDefault?: boolean;
+};
+
+export type ZcaFriend = {
+  userId: string;
+  displayName: string;
+  avatar?: string;
+};
+
+export type ZcaGroup = {
+  groupId: string;
+  name: string;
+  memberCount?: number;
+};
+
+export type ZcaMessage = {
+  threadId: string;
+  msgId?: string;
+  cliMsgId?: string;
+  type: number;
+  content: string;
+  timestamp: number;
+  metadata?: {
+    isGroup: boolean;
+    threadName?: string;
+    senderName?: string;
+    fromId?: string;
+  };
+};
+
+export type ZcaUserInfo = {
+  userId: string;
+  displayName: string;
+  avatar?: string;
+};
+
+export type CommonOptions = {
+  profile?: string;
+  json?: boolean;
+};
+
+export type SendOptions = CommonOptions & {
+  group?: boolean;
+};
+
+export type ListenOptions = CommonOptions & {
+  raw?: boolean;
+  keepAlive?: boolean;
+  webhook?: string;
+  echo?: boolean;
+  prefix?: string;
+};
+
+type ZalouserToolConfig = { allow?: string[]; deny?: string[] };
+
+type ZalouserGroupConfig = {
+  allow?: boolean;
+  enabled?: boolean;
+  tools?: ZalouserToolConfig;
+};
+
+type ZalouserSharedConfig = {
+  enabled?: boolean;
+  name?: string;
+  profile?: string;
+  dmPolicy?: "pairing" | "allowlist" | "open" | "disabled";
+  allowFrom?: Array<string | number>;
+  groupPolicy?: "open" | "allowlist" | "disabled";
+  groups?: Record<string, ZalouserGroupConfig>;
+  messagePrefix?: string;
+  responsePrefix?: string;
+};
+
+export type ZalouserAccountConfig = ZalouserSharedConfig;
+
+export type ZalouserConfig = ZalouserSharedConfig & {
+  defaultAccount?: string;
+  accounts?: Record<string, ZalouserAccountConfig>;
+};
+
+export type ResolvedZalouserAccount = {
+  accountId: string;
+  name?: string;
+  enabled: boolean;
+  profile: string;
+  authenticated: boolean;
+  config: ZalouserAccountConfig;
+};

package/extensions/zalouser/src/zca.ts

@@ -0,0 +1,198 @@
+import { spawn, type SpawnOptions } from "node:child_process";
+import { stripAnsi } from "remoteclaw/plugin-sdk";
+import type { ZcaResult, ZcaRunOptions } from "./types.js";
+
+const ZCA_BINARY = "zca";
+const DEFAULT_TIMEOUT = 30000;
+
+function buildArgs(args: string[], options?: ZcaRunOptions): string[] {
+  const result: string[] = [];
+  // Profile flag comes first (before subcommand)
+  const profile = options?.profile || process.env.ZCA_PROFILE;
+  if (profile) {
+    result.push("--profile", profile);
+  }
+  result.push(...args);
+  return result;
+}
+
+export async function runZca(args: string[], options?: ZcaRunOptions): Promise<ZcaResult> {
+  const fullArgs = buildArgs(args, options);
+  const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
+
+  return new Promise((resolve) => {
+    const spawnOpts: SpawnOptions = {
+      cwd: options?.cwd,
+      env: { ...process.env },
+      stdio: ["pipe", "pipe", "pipe"],
+    };
+
+    const proc = spawn(ZCA_BINARY, fullArgs, spawnOpts);
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+
+    const timer = setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGTERM");
+    }, timeout);
+
+    proc.stdout?.on("data", (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr?.on("data", (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      if (timedOut) {
+        resolve({
+          ok: false,
+          stdout,
+          stderr: stderr || "Command timed out",
+          exitCode: code ?? 124,
+        });
+        return;
+      }
+      resolve({
+        ok: code === 0,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: code ?? 1,
+      });
+    });
+
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({
+        ok: false,
+        stdout: "",
+        stderr: err.message,
+        exitCode: 1,
+      });
+    });
+  });
+}
+
+export function runZcaInteractive(args: string[], options?: ZcaRunOptions): Promise<ZcaResult> {
+  const fullArgs = buildArgs(args, options);
+
+  return new Promise((resolve) => {
+    const spawnOpts: SpawnOptions = {
+      cwd: options?.cwd,
+      env: { ...process.env },
+      stdio: "inherit",
+    };
+
+    const proc = spawn(ZCA_BINARY, fullArgs, spawnOpts);
+
+    proc.on("close", (code) => {
+      resolve({
+        ok: code === 0,
+        stdout: "",
+        stderr: "",
+        exitCode: code ?? 1,
+      });
+    });
+
+    proc.on("error", (err) => {
+      resolve({
+        ok: false,
+        stdout: "",
+        stderr: err.message,
+        exitCode: 1,
+      });
+    });
+  });
+}
+
+export function parseJsonOutput<T>(stdout: string): T | null {
+  try {
+    return JSON.parse(stdout) as T;
+  } catch {
+    const cleaned = stripAnsi(stdout);
+
+    try {
+      return JSON.parse(cleaned) as T;
+    } catch {
+      // zca may prefix output with INFO/log lines, try to find JSON
+      const lines = cleaned.split("\n");
+
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith("{") || line.startsWith("[")) {
+          // Try parsing from this line to the end
+          const jsonCandidate = lines.slice(i).join("\n").trim();
+          try {
+            return JSON.parse(jsonCandidate) as T;
+          } catch {
+            continue;
+          }
+        }
+      }
+      return null;
+    }
+  }
+}
+
+export async function checkZcaInstalled(): Promise<boolean> {
+  const result = await runZca(["--version"], { timeout: 5000 });
+  return result.ok;
+}
+
+export type ZcaStreamingOptions = ZcaRunOptions & {
+  onData?: (data: string) => void;
+  onError?: (err: Error) => void;
+};
+
+export function runZcaStreaming(
+  args: string[],
+  options?: ZcaStreamingOptions,
+): { proc: ReturnType<typeof spawn>; promise: Promise<ZcaResult> } {
+  const fullArgs = buildArgs(args, options);
+
+  const spawnOpts: SpawnOptions = {
+    cwd: options?.cwd,
+    env: { ...process.env },
+    stdio: ["pipe", "pipe", "pipe"],
+  };
+
+  const proc = spawn(ZCA_BINARY, fullArgs, spawnOpts);
+  let stdout = "";
+  let stderr = "";
+
+  proc.stdout?.on("data", (data: Buffer) => {
+    const text = data.toString();
+    stdout += text;
+    options?.onData?.(text);
+  });
+
+  proc.stderr?.on("data", (data: Buffer) => {
+    stderr += data.toString();
+  });
+
+  const promise = new Promise<ZcaResult>((resolve) => {
+    proc.on("close", (code) => {
+      resolve({
+        ok: code === 0,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: code ?? 1,
+      });
+    });
+
+    proc.on("error", (err) => {
+      options?.onError?.(err);
+      resolve({
+        ok: false,
+        stdout: "",
+        stderr: err.message,
+        exitCode: 1,
+      });
+    });
+  });
+
+  return { proc, promise };
+}