autocrew 0.1.0

package/src/adapters/browser/browser-relay.ts

@@ -0,0 +1,236 @@
+/**
+ * Browser Relay Adapter — uses OpenClaw Gateway + Chrome Relay
+ *
+ * Controls the user's real browser via OpenClaw Gateway HTTP API.
+ * Falls back to the legacy CDP proxy adapter if Gateway is unavailable.
+ */
+import { GatewayClient } from "./gateway-client.js";
+import { browserCdpAdapter } from "./browser-cdp.js";
+import type {
+  BrowserAdapter,
+  BrowserPlatform,
+  BrowserResearchQuery,
+  BrowserSessionStatus,
+  ResearchItem,
+} from "./types.js";
+
+function buildPlatformUrl(platform: BrowserPlatform): string {
+  const urls: Record<BrowserPlatform, string> = {
+    xiaohongshu: "https://www.xiaohongshu.com/",
+    douyin: "https://www.douyin.com/",
+    wechat_mp: "https://mp.weixin.qq.com/",
+    wechat_video: "https://channels.weixin.qq.com/platform/",
+    bilibili: "https://www.bilibili.com/",
+  };
+  return urls[platform] || urls.xiaohongshu;
+}
+
+function buildSearchUrl(platform: BrowserPlatform, keyword: string): string {
+  const encoded = encodeURIComponent(keyword);
+  const urls: Record<BrowserPlatform, string> = {
+    xiaohongshu: `https://www.xiaohongshu.com/search_result?keyword=${encoded}`,
+    douyin: `https://www.douyin.com/search/${encoded}?type=video`,
+    bilibili: `https://search.bilibili.com/all?keyword=${encoded}`,
+    wechat_mp: `https://weixin.sogou.com/weixin?type=2&query=${encoded}`,
+    wechat_video: `https://channels.weixin.qq.com/platform/`,
+  };
+  return urls[platform] || urls.xiaohongshu;
+}
+
+/** JS expression to check login status via page content */
+function sessionCheckExpression(platform: BrowserPlatform): string {
+  return `(() => {
+    const href = location.href;
+    const text = (document.body?.innerText || "").slice(0, 2000);
+    const checks = {
+      xiaohongshu: /login|登录/.test(href) || /登录后查看更多|立即登录/.test(text),
+      douyin: /login|sso\\.douyin/.test(href) || /扫码登录|手机号登录/.test(text),
+      wechat_mp: /login/.test(href) || /扫码登录|微信公众平台/.test(text),
+      wechat_video: /login/.test(href) || /扫码登录|视频号助手/.test(text),
+      bilibili: /passport|login/.test(href) || /请先登录|登录后/.test(text),
+    };
+    const loggedIn = !checks[${JSON.stringify(platform)}];
+    return JSON.stringify({
+      href,
+      title: document.title,
+      loggedIn,
+      textHint: text.slice(0, 200),
+    });
+  })()`;
+}
+
+/** JS expression to extract research results from search page */
+function researchExpression(platform: BrowserPlatform, limit: number): string {
+  return `(() => {
+    const limit = ${limit};
+    const abs = (href) => {
+      try { return new URL(href, location.href).href; } catch { return href || ""; }
+    };
+    const dedupe = new Set();
+    const push = (items, item) => {
+      if (!item || !item.title) return;
+      const key = item.title + "::" + (item.url || "");
+      if (dedupe.has(key)) return;
+      dedupe.add(key);
+      items.push(item);
+    };
+    const text = (el) => (el?.innerText || el?.textContent || "").replace(/\\s+/g, " ").trim();
+    const items = [];
+
+    if (${JSON.stringify(platform)} === "xiaohongshu") {
+      const cards = Array.from(document.querySelectorAll("section, .note-item, [data-index], a"));
+      for (const card of cards) {
+        const titleEl = card.querySelector?.("a[href*='/explore/'], a[href*='/discovery/item/'], a[href*='/note/'], .title span, .desc, .note-title") || card;
+        const linkEl = card.querySelector?.("a[href*='/explore/'], a[href*='/discovery/item/'], a[href*='/note/']") || card.closest?.("a");
+        const authorEl = card.querySelector?.(".author, .name");
+        const title = text(titleEl);
+        const url = linkEl?.href ? abs(linkEl.href) : "";
+        if (title.length >= 4 && url.includes("xiaohongshu.com")) {
+          push(items, { title, url, author: text(authorEl) });
+        }
+        if (items.length >= limit) break;
+      }
+    } else if (${JSON.stringify(platform)} === "douyin") {
+      const cards = Array.from(document.querySelectorAll("a[href*='/video/'], [data-e2e='search-result-container'] a, .ECMy_Zdt"));
+      for (const card of cards) {
+        const titleEl = card.querySelector?.("span, p, h3") || card;
+        const url = card.href ? abs(card.href) : abs(card.querySelector?.("a")?.href || "");
+        const title = text(titleEl);
+        if (title.length >= 4 && url.includes("douyin.com")) {
+          push(items, { title, url });
+        }
+        if (items.length >= limit) break;
+      }
+    } else if (${JSON.stringify(platform)} === "bilibili") {
+      const cards = Array.from(document.querySelectorAll("a[href*='/video/'], .bili-video-card a, .video-list-item a"));
+      for (const card of cards) {
+        const title = card.getAttribute?.("title") || text(card);
+        const url = card.href ? abs(card.href) : "";
+        if (title && url.includes("bilibili.com")) {
+          push(items, { title, url });
+        }
+        if (items.length >= limit) break;
+      }
+    } else {
+      const links = Array.from(document.querySelectorAll("a"));
+      for (const link of links) {
+        const title = text(link);
+        const url = link.href ? abs(link.href) : "";
+        if (title.length >= 6 && url) {
+          push(items, { title, url });
+        }
+        if (items.length >= limit) break;
+      }
+    }
+
+    return JSON.stringify(items.slice(0, limit));
+  })()`;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// --- Relay Adapter ---
+
+async function getSessionStatus(
+  platform: BrowserPlatform,
+  gatewayUrl?: string,
+): Promise<BrowserSessionStatus> {
+  const gw = new GatewayClient(gatewayUrl);
+  const available = await gw.isAvailable();
+
+  if (!available) {
+    // Fallback to legacy CDP adapter
+    if (browserCdpAdapter.getSessionStatus) {
+      return browserCdpAdapter.getSessionStatus(platform);
+    }
+    return { platform, loggedIn: false, note: "Gateway unavailable, no fallback" };
+  }
+
+  try {
+    // Navigate to platform homepage
+    const navResult = await gw.navigate(buildPlatformUrl(platform));
+    if (!navResult.ok) {
+      return { platform, loggedIn: false, note: navResult.error || "navigate failed" };
+    }
+
+    await sleep(2000);
+
+    // Evaluate login check expression
+    const evalResult = await gw.evaluate(sessionCheckExpression(platform));
+    if (!evalResult.ok || evalResult.value === undefined) {
+      return { platform, loggedIn: false, note: evalResult.error || "eval failed" };
+    }
+
+    const parsed = typeof evalResult.value === "string"
+      ? JSON.parse(evalResult.value)
+      : evalResult.value;
+
+    return {
+      platform,
+      loggedIn: Boolean(parsed.loggedIn),
+      note: parsed.href || parsed.title || "session checked via relay",
+    };
+  } catch (error: any) {
+    return { platform, loggedIn: false, note: error?.message || "relay session check failed" };
+  }
+}
+
+async function research(
+  query: BrowserResearchQuery,
+  gatewayUrl?: string,
+): Promise<ResearchItem[]> {
+  const gw = new GatewayClient(gatewayUrl);
+  const available = await gw.isAvailable();
+
+  if (!available) {
+    // Fallback to legacy CDP adapter
+    return browserCdpAdapter.research(query);
+  }
+
+  try {
+    // Navigate to search URL
+    const navResult = await gw.navigate(buildSearchUrl(query.platform, query.keyword));
+    if (!navResult.ok) return [];
+
+    await sleep(3000); // Wait for search results to load
+
+    // Extract results via JS evaluation
+    const evalResult = await gw.evaluate(researchExpression(query.platform, query.limit || 5));
+    if (!evalResult.ok || evalResult.value === undefined) return [];
+
+    const parsed = typeof evalResult.value === "string"
+      ? JSON.parse(evalResult.value as string)
+      : evalResult.value;
+
+    if (!Array.isArray(parsed)) return [];
+
+    return parsed.map((item: any) => ({
+      title: String(item.title || "").trim(),
+      summary: item.author
+        ? `参考账号：${String(item.author).trim()}`
+        : "来自 Chrome Relay 登录态搜索结果",
+      url: item.url ? String(item.url) : undefined,
+      author: item.author ? String(item.author) : undefined,
+      platform: query.platform,
+      source: "browser_relay" as const,
+    }));
+  } catch {
+    // Fallback to legacy CDP adapter
+    return browserCdpAdapter.research(query);
+  }
+}
+
+export function createBrowserRelayAdapter(gatewayUrl?: string): BrowserAdapter {
+  return {
+    id: "browser_relay",
+    description:
+      "Browser adapter using OpenClaw Gateway + Chrome Relay. Controls the user's real Chrome browser with existing login sessions.",
+    getSessionStatus: (platform) => getSessionStatus(platform, gatewayUrl),
+    research: (query) => research(query, gatewayUrl),
+  };
+}
+
+/** Default instance using env/default gateway URL */
+export const browserRelayAdapter = createBrowserRelayAdapter();

package/src/adapters/browser/gateway-client.ts

@@ -0,0 +1,148 @@
+/**
+ * OpenClaw Gateway HTTP Client
+ *
+ * Communicates with the OpenClaw Gateway to execute browser operations
+ * via Chrome Relay. Uses the user's real browser sessions (logged-in state).
+ *
+ * Gateway default: http://127.0.0.1:18789
+ */
+
+const DEFAULT_GATEWAY_URL =
+  process.env.AUTOCREW_GATEWAY_URL || "http://127.0.0.1:18789";
+
+const REQUEST_TIMEOUT_MS = 30_000;
+
+export interface GatewayBrowserAction {
+  action: "navigate" | "click" | "type" | "screenshot" | "snapshot" | "evaluate";
+  url?: string;
+  /** Element reference ID (from snapshot) */
+  ref?: number;
+  /** Text to type */
+  text?: string;
+  /** JavaScript expression to evaluate */
+  expression?: string;
+  /** Coordinate-based click */
+  coordinate?: [number, number];
+}
+
+export interface GatewaySnapshot {
+  /** Page URL */
+  url: string;
+  /** Page title */
+  title: string;
+  /** Accessibility tree / element list with ref IDs */
+  elements: GatewaySnapshotElement[];
+  /** Raw page text (truncated) */
+  pageText?: string;
+}
+
+export interface GatewaySnapshotElement {
+  ref: number;
+  role: string;
+  name: string;
+  /** Additional attributes */
+  attrs?: Record<string, string>;
+}
+
+export interface GatewayBrowserResult {
+  ok: boolean;
+  /** Snapshot after the action */
+  snapshot?: GatewaySnapshot;
+  /** Screenshot base64 (if action=screenshot) */
+  screenshot?: string;
+  /** Evaluation result (if action=evaluate) */
+  value?: unknown;
+  error?: string;
+}
+
+export interface GatewaySession {
+  id: string;
+  /** Tab URL */
+  url: string;
+  title: string;
+}
+
+export class GatewayClient {
+  readonly baseUrl: string;
+
+  constructor(gatewayUrl?: string) {
+    this.baseUrl = (gatewayUrl || DEFAULT_GATEWAY_URL).replace(/\/+$/, "");
+  }
+
+  /** Check if the Gateway is running and reachable */
+  async isAvailable(): Promise<boolean> {
+    try {
+      const res = await fetch(`${this.baseUrl}/health`, {
+        signal: AbortSignal.timeout(3_000),
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  /** Execute a browser action through the Gateway */
+  async browser(action: GatewayBrowserAction): Promise<GatewayBrowserResult> {
+    const res = await fetch(`${this.baseUrl}/tools/browser`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(action),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      return { ok: false, error: `Gateway returned ${res.status}: ${text}` };
+    }
+
+    try {
+      const data = await res.json();
+      return { ok: true, ...data };
+    } catch {
+      return { ok: false, error: "Gateway returned non-JSON response" };
+    }
+  }
+
+  /** Navigate to a URL and return a snapshot */
+  async navigate(url: string): Promise<GatewayBrowserResult> {
+    return this.browser({ action: "navigate", url });
+  }
+
+  /** Take a page snapshot (accessibility tree with element refs) */
+  async snapshot(): Promise<GatewayBrowserResult> {
+    return this.browser({ action: "snapshot" });
+  }
+
+  /** Click an element by ref ID */
+  async click(ref: number): Promise<GatewayBrowserResult> {
+    return this.browser({ action: "click", ref });
+  }
+
+  /** Type text into the focused element */
+  async type(text: string): Promise<GatewayBrowserResult> {
+    return this.browser({ action: "type", text });
+  }
+
+  /** Take a screenshot (returns base64 PNG) */
+  async screenshot(): Promise<GatewayBrowserResult> {
+    return this.browser({ action: "screenshot" });
+  }
+
+  /** Evaluate a JavaScript expression in the page context */
+  async evaluate(expression: string): Promise<GatewayBrowserResult> {
+    return this.browser({ action: "evaluate", expression });
+  }
+
+  /** List active browser sessions */
+  async listSessions(): Promise<GatewaySession[]> {
+    try {
+      const res = await fetch(`${this.baseUrl}/sessions`, {
+        signal: AbortSignal.timeout(5_000),
+      });
+      if (!res.ok) return [];
+      return (await res.json()) as GatewaySession[];
+    } catch {
+      return [];
+    }
+  }
+}

package/src/adapters/browser/types.ts

@@ -0,0 +1,36 @@
+export type BrowserPlatform =
+  | "xiaohongshu"
+  | "douyin"
+  | "wechat_mp"
+  | "wechat_video"
+  | "bilibili";
+
+export interface BrowserSessionStatus {
+  platform: BrowserPlatform;
+  loggedIn: boolean;
+  profileName?: string;
+  note?: string;
+}
+
+export interface ResearchItem {
+  title: string;
+  summary?: string;
+  url?: string;
+  author?: string;
+  metrics?: Record<string, number | string>;
+  platform: BrowserPlatform;
+  source: "browser_cdp" | "browser_relay" | "api_provider" | "manual";
+}
+
+export interface BrowserResearchQuery {
+  platform: BrowserPlatform;
+  keyword: string;
+  limit?: number;
+}
+
+export interface BrowserAdapter {
+  id: string;
+  description: string;
+  getSessionStatus?(platform: BrowserPlatform): Promise<BrowserSessionStatus>;
+  research(query: BrowserResearchQuery): Promise<ResearchItem[]>;
+}

package/src/adapters/image/gemini.ts

@@ -0,0 +1,219 @@
+/**
+ * Gemini Image Adapter — generates images via Gemini API.
+ *
+ * Supports two models:
+ * - gemini-native: Gemini 2.5 Flash Image (multimodal output, supports reference images)
+ * - imagen-4: Imagen 4.0 (text-to-image only, being deprecated June 2026)
+ *
+ * "auto" mode tries gemini-native first (recommended), falls back to imagen-4.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { withRetry, checkFetchResponse } from "../../utils/retry.js";
+
+// --- Types ---
+
+export type GeminiModel = "gemini-native" | "imagen-4" | "auto";
+export type AspectRatio = "3:4" | "16:9" | "4:3" | "1:1";
+
+export interface GeminiImageOptions {
+  prompt: string;
+  aspectRatio: AspectRatio;
+  model: GeminiModel;
+  apiKey: string;
+  /** Optional reference image paths (e.g. personal IP photos) */
+  referenceImagePaths?: string[];
+  /** Where to save the generated image */
+  outputPath: string;
+  /** Image resolution: "1K" | "2K". Default "1K" */
+  resolution?: string;
+}
+
+export interface GeminiImageResult {
+  ok: boolean;
+  imagePath: string;
+  model: string;
+  mimeType?: string;
+  error?: string;
+}
+
+// --- Constants ---
+
+const GEMINI_API_BASE = "https://generativelanguage.googleapis.com/v1beta";
+const MODEL_NATIVE = "gemini-2.5-flash-preview-image-generation";
+const MODEL_IMAGEN = "imagen-4.0-generate-001";
+
+// --- Helpers ---
+
+async function fileToBase64(filePath: string): Promise<{ data: string; mimeType: string }> {
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeMap: Record<string, string> = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".webp": "image/webp",
+  };
+  const mimeType = mimeMap[ext] || "image/jpeg";
+  const buffer = await fs.readFile(filePath);
+  return { data: buffer.toString("base64"), mimeType };
+}
+
+// --- Gemini Native (2.5 Flash Image) ---
+
+async function generateNative(options: GeminiImageOptions): Promise<GeminiImageResult> {
+  const { prompt, aspectRatio, apiKey, referenceImagePaths, outputPath, resolution } = options;
+
+  // Build parts array
+  const parts: any[] = [{ text: prompt }];
+
+  // Add reference images if provided
+  if (referenceImagePaths?.length) {
+    for (const refPath of referenceImagePaths) {
+      try {
+        const { data, mimeType } = await fileToBase64(refPath);
+        parts.push({ inline_data: { mime_type: mimeType, data } });
+      } catch {
+        // Skip unreadable reference images
+      }
+    }
+  }
+
+  const body = {
+    contents: [{ parts }],
+    generationConfig: {
+      responseModalities: ["TEXT", "IMAGE"],
+      imageConfig: {
+        aspectRatio,
+        imageSize: resolution || "1K",
+      },
+    },
+  };
+
+  const url = `${GEMINI_API_BASE}/models/${MODEL_NATIVE}:generateContent?key=${apiKey}`;
+
+  let json: any;
+  try {
+    json = await withRetry(async () => {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      });
+      checkFetchResponse(res, "Gemini Native");
+      return res.json();
+    });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, imagePath: "", model: MODEL_NATIVE, error: message };
+  }
+
+  // Extract image from response
+  const candidates = json.candidates || [];
+  for (const candidate of candidates) {
+    for (const part of candidate.content?.parts || []) {
+      if (part.inlineData?.data) {
+        const buffer = Buffer.from(part.inlineData.data, "base64");
+        const mimeType = part.inlineData.mimeType || "image/png";
+        const ext = mimeType.includes("jpeg") ? ".jpg" : ".png";
+        const finalPath = outputPath.endsWith(ext) ? outputPath : outputPath + ext;
+
+        await fs.mkdir(path.dirname(finalPath), { recursive: true });
+        await fs.writeFile(finalPath, buffer);
+
+        return { ok: true, imagePath: finalPath, model: MODEL_NATIVE, mimeType };
+      }
+    }
+  }
+
+  return { ok: false, imagePath: "", model: MODEL_NATIVE, error: "No image in response" };
+}
+
+// --- Imagen 4 ---
+
+async function generateImagen(options: GeminiImageOptions): Promise<GeminiImageResult> {
+  const { prompt, aspectRatio, apiKey, outputPath } = options;
+
+  // Imagen 4 uses a different API format
+  const body = {
+    instances: [{ prompt }],
+    parameters: {
+      sampleCount: 1,
+      aspectRatio,
+    },
+  };
+
+  const url = `${GEMINI_API_BASE}/models/${MODEL_IMAGEN}:predict?key=${apiKey}`;
+
+  let json: any;
+  try {
+    json = await withRetry(async () => {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      });
+      checkFetchResponse(res, "Imagen 4");
+      return res.json();
+    });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, imagePath: "", model: MODEL_IMAGEN, error: message };
+  }
+  const predictions = json.predictions || [];
+
+  if (predictions.length > 0 && predictions[0].bytesBase64Encoded) {
+    const buffer = Buffer.from(predictions[0].bytesBase64Encoded, "base64");
+    const finalPath = outputPath.endsWith(".png") ? outputPath : outputPath + ".png";
+
+    await fs.mkdir(path.dirname(finalPath), { recursive: true });
+    await fs.writeFile(finalPath, buffer);
+
+    return { ok: true, imagePath: finalPath, model: MODEL_IMAGEN, mimeType: "image/png" };
+  }
+
+  return { ok: false, imagePath: "", model: MODEL_IMAGEN, error: "No image in Imagen response" };
+}
+
+// --- Public API ---
+
+/**
+ * Generate an image using Gemini API.
+ *
+ * "auto" mode tries gemini-native first, falls back to imagen-4.
+ * gemini-native supports reference images; imagen-4 does not.
+ */
+export async function generateImage(options: GeminiImageOptions): Promise<GeminiImageResult> {
+  const model = options.model || "auto";
+
+  if (model === "gemini-native") {
+    return generateNative(options);
+  }
+
+  if (model === "imagen-4") {
+    return generateImagen(options);
+  }
+
+  // auto: try native first, fall back to imagen-4
+  const nativeResult = await generateNative(options);
+  if (nativeResult.ok) return nativeResult;
+
+  // Fallback — imagen-4 doesn't support reference images
+  const imagenOptions = { ...options, referenceImagePaths: undefined };
+  return generateImagen(imagenOptions);
+}
+
+/**
+ * List available personal IP reference photos from the templates directory.
+ */
+export async function listReferencePhotos(dataDir?: string): Promise<string[]> {
+  const home = process.env.HOME || process.env.USERPROFILE || "~";
+  const dir = path.join(dataDir || path.join(home, ".autocrew"), "covers", "templates");
+  try {
+    const files = await fs.readdir(dir);
+    return files
+      .filter((f) => /\.(jpg|jpeg|png|webp)$/i.test(f))
+      .map((f) => path.join(dir, f));
+  } catch {
+    return [];
+  }
+}

package/src/adapters/research/tikhub.ts

@@ -0,0 +1,19 @@
+import type { BrowserPlatform, ResearchItem } from "../browser/types.js";
+
+export interface TikHubResearchQuery {
+  platform: BrowserPlatform;
+  keyword: string;
+  limit?: number;
+}
+
+export async function researchWithTikHub(
+  query: TikHubResearchQuery,
+): Promise<ResearchItem[]> {
+  const limit = query.limit || 5;
+  return Array.from({ length: limit }).map((_, index) => ({
+    title: `${query.keyword} API 候选 ${index + 1}`,
+    summary: "TikHub fallback placeholder. Replace with a real provider call only when browser-first mode is unavailable.",
+    platform: query.platform,
+    source: "api_provider",
+  }));
+}

package/src/cli/banner.ts

@@ -0,0 +1,18 @@
+/**
+ * ASCII art banner for AutoCrew CLI.
+ * Only displayed when stdout is a TTY.
+ */
+
+const LOGO = `
+\x1b[38;5;196m    _         _         ____
+   / \\  _   _| |_ ___  / ___|_ __ _____      __
+  / _ \\| | | | __/ _ \\| |   | '__/ _ \\ \\ /\\ / /
+ / ___ \\ |_| | || (_) | |___| | |  __/\\ V  V /
+/_/   \\_\\__,_|\\__\\___/ \\____|_|  \\___| \\_/\\_/\x1b[0m`;
+
+export function showBanner(version: string): void {
+  if (!process.stdout.isTTY) return;
+  console.log(LOGO);
+  console.log(`\x1b[2m  v${version} — AI content operations crew\x1b[0m`);
+  console.log();
+}