@insta-dev01/insta-plugin-openclaw 1.0.0 → 1.0.2

package/src/channel/dispatcher.ts

@@ -1,374 +0,0 @@
-import type { WebSocket } from "ws";
-import type { DebugLogger } from "./logger.js";
-import {
-  createInProgressEvent,
-  createOutputItemAddedEvent,
-  createOutputTextDeltaEvent,
-  createContentPartDoneEvent,
-  createCompletedEvent,
-  createFailedEvent,
-  createEnvelope,
-} from "./protocol.js";
-
-// ── Types ─────────────────────────────────────────────────────────────────────
-
-export type SDKCallback = (chunk: string | null, error: Error | null, isComplete: boolean) => void;
-
-interface RequestContext {
-  messageId: string;
-  responseId: string;
-  itemId: string;
-  content: string;
-  requestTimestamp: number;
-  responseBuffer: string;
-  firstChunkReceived: boolean;
-  timeoutTimer: NodeJS.Timeout | null;
-  abortController: AbortController | null;
-  status: "pending" | "processing" | "completed" | "failed" | "timeout";
-  ws: WebSocket;
-  sessionId: string;
-}
-
-export interface DispatcherConfig {
-  requestTimeout: number;
-  maxConcurrentRequests: number;
-  debug: boolean;
-  systemPrompt?: string;
-  accountId?: string;
-  cfg?: unknown;
-}
-
-// ── SDKDispatcher ─────────────────────────────────────────────────────────────
-
-export class SDKDispatcher {
-  private contexts = new Map<string, RequestContext>();
-
-  constructor(
-    private config: DispatcherConfig,
-    private logger: DebugLogger,
-    private accountId?: string,
-    private channelRuntime?: unknown,
-  ) {
-    this.logger.info("SDKDispatcher initialized", {
-      requestTimeout: config.requestTimeout,
-      maxConcurrentRequests: config.maxConcurrentRequests,
-      hasChannelRuntime: !!channelRuntime,
-      accountId,
-    });
-  }
-
-  async dispatchRequest(
-    request: { content: string; messageId: string; sessionId?: string },
-    ws: WebSocket,
-  ): Promise<void> {
-    const sessionId = request.sessionId ?? "";
-
-    if (!request.content?.trim()) {
-      const responseId = this.newId("resp");
-      await this.sendFailedEvent(ws, responseId, "INVALID_REQUEST", "Request content must be non-empty", sessionId);
-      return;
-    }
-
-    if (this.activeCount() >= this.config.maxConcurrentRequests) {
-      const responseId = this.newId("resp");
-      await this.sendFailedEvent(ws, responseId, "RATE_LIMIT", "Maximum concurrent requests exceeded", sessionId);
-      return;
-    }
-
-    const responseId = this.newId("resp");
-    const itemId = this.newId("item");
-    const abortController = new AbortController();
-
-    const ctx: RequestContext = {
-      messageId: request.messageId,
-      responseId,
-      itemId,
-      content: request.content,
-      requestTimestamp: Date.now(),
-      responseBuffer: "",
-      firstChunkReceived: false,
-      timeoutTimer: null,
-      abortController,
-      status: "pending",
-      ws,
-      sessionId,
-    };
-
-    this.contexts.set(request.messageId, ctx);
-    this.logger.info("Dispatching request", {
-      messageId: request.messageId,
-      responseId,
-      sessionId,
-      contentLength: request.content.length,
-    });
-
-    ctx.timeoutTimer = setTimeout(() => this.handleTimeout(request.messageId), this.config.requestTimeout);
-    ctx.status = "processing";
-
-    try {
-      await this.realSDKDispatch(request.content, this.createCallback(request.messageId), abortController.signal, sessionId);
-    } catch (err) {
-      if (err instanceof Error && err.name === "AbortError") return;
-      await this.handleError(ctx, err instanceof Error ? err : new Error(String(err)));
-    }
-  }
-
-  activeCount(): number {
-    let n = 0;
-    for (const c of this.contexts.values()) {
-      if (c.status === "pending" || c.status === "processing") n++;
-    }
-    return n;
-  }
-
-  // ── Private ─────────────────────────────────────────────────────────────────
-
-  private newId(prefix: string): string {
-    return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
-  }
-
-  private buildSessionKey(sessionId?: string): string {
-    const account = this.accountId ?? "default";
-    return sessionId ? `instaclaw:${account}:${sessionId}` : `instaclaw:${account}`;
-  }
-
-  private async sendFailedEvent(ws: WebSocket, responseId: string, code: string, message: string, sessionId?: string): Promise<void> {
-    try {
-      if (ws.readyState === 1) {
-        ws.send(createEnvelope(createFailedEvent(responseId, code, message, null, sessionId)));
-      }
-    } catch (err) {
-      this.logger.error("Failed to send failed event", err);
-    }
-  }
-
-  private async realSDKDispatch(
-    content: string,
-    callback: SDKCallback,
-    signal?: AbortSignal,
-    sessionId?: string,
-  ): Promise<void> {
-    const runtime = this.channelRuntime as {
-      reply?: {
-        dispatchReplyWithBufferedBlockDispatcher?: (opts: unknown) => Promise<void>;
-      };
-    } | undefined;
-
-    if (!runtime?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
-      this.logger.warn("channelRuntime not available — falling back to echo");
-      await new Promise<void>((resolve) => {
-        setTimeout(() => {
-          if (!signal?.aborted) callback("[no AI runtime] echo: " + content.substring(0, 50), null, false);
-          setTimeout(() => {
-            if (!signal?.aborted) callback(null, null, true);
-            resolve();
-          }, 50);
-        }, 50);
-      });
-      return;
-    }
-
-    const baseSystemPrompt = (this.config.systemPrompt ?? "");
-    const sessionInstruction = sessionId
-      ? `\n\n【当前会话信息】\n当前雇佣会话 sessionId 为：${sessionId}\n当你调用 insta_upload_artifact 上传文件时，必须将此 sessionId 作为参数传入，以便系统自动将产物与本次雇佣会话关联。`
-      : "";
-    const resolvedSystemPrompt = (baseSystemPrompt + sessionInstruction).trim() || undefined;
-
-    const msgCtx = {
-      Body: content,
-      AccountId: this.accountId,
-      SessionKey: this.buildSessionKey(sessionId),
-      ...(resolvedSystemPrompt ? { SystemPrompt: resolvedSystemPrompt } : {}),
-    };
-
-    let alreadyCompleted = false;
-    const safeComplete = () => {
-      if (alreadyCompleted || signal?.aborted) return;
-      alreadyCompleted = true;
-      callback(null, null, true);
-    };
-
-    let streamedAnyChunks = false;
-    let previousAccumulatedText = "";
-
-    await runtime.reply.dispatchReplyWithBufferedBlockDispatcher({
-      ctx: msgCtx,
-      cfg: this.config.cfg,
-      replyOptions: {
-        abortSignal: signal,
-        onPartialReply: (payload: { text?: string }) => {
-          if (signal?.aborted) return;
-          if (payload.text && payload.text.length > previousAccumulatedText.length) {
-            const delta = payload.text.substring(previousAccumulatedText.length);
-            previousAccumulatedText = payload.text;
-            if (delta) {
-              streamedAnyChunks = true;
-              callback(delta, null, false);
-            }
-          }
-        },
-      },
-      dispatcherOptions: {
-        deliver: async (payload: { text?: string }) => {
-          if (signal?.aborted) return;
-          if (!streamedAnyChunks && payload.text) {
-            callback(payload.text, null, false);
-          }
-          safeComplete();
-        },
-        onError: (err: unknown) => {
-          callback(null, err instanceof Error ? err : new Error(String(err)), false);
-        },
-      },
-    });
-
-    safeComplete();
-  }
-
-  private createCallback(messageId: string): SDKCallback {
-    return (chunk, error, isComplete) => {
-      try {
-        const ctx = this.contexts.get(messageId);
-        if (!ctx) {
-          this.logger.warn("Callback for unknown messageId", { messageId });
-          return;
-        }
-
-        if (error) {
-          this.handleError(ctx, error).catch((e) => this.logger.error("Error in handleError", e));
-          return;
-        }
-
-        if (isComplete) {
-          this.handleCompletion(ctx).catch((e) => this.logger.error("Error in handleCompletion", e));
-          return;
-        }
-
-        if (chunk) {
-          this.handleChunk(ctx, chunk).catch((e) => this.logger.error("Error in handleChunk", e));
-        }
-      } catch (e) {
-        this.logger.error("Callback threw", e);
-      }
-    };
-  }
-
-  private handleTimeout(messageId: string): void {
-    const ctx = this.contexts.get(messageId);
-    if (!ctx) return;
-
-    this.logger.warn("Request timeout", { messageId, responseId: ctx.responseId });
-    ctx.status = "timeout";
-
-    this.generateFailedEvent(ctx, "TIMEOUT", `Request timed out after ${this.config.requestTimeout}ms`, {
-      timeoutDuration: this.config.requestTimeout,
-    }).catch((e) => this.logger.error("Failed to generate timeout event", e));
-
-    ctx.abortController?.abort();
-    this.cleanupContext(messageId);
-  }
-
-  private sendWs(ctx: RequestContext, data: string): void {
-    if (ctx.ws.readyState === 1) {
-      ctx.ws.send(data);
-    } else {
-      this.logger.warn("WebSocket not open, dropping event", { responseId: ctx.responseId, readyState: ctx.ws.readyState });
-    }
-  }
-
-  private async generateInProgressEvent(ctx: RequestContext): Promise<void> {
-    try {
-      this.sendWs(ctx, createEnvelope(createInProgressEvent(ctx.responseId, ctx.sessionId)));
-    } catch (e) { this.logger.error("Failed to send in_progress", e); }
-  }
-
-  private async generateItemAddedEvent(ctx: RequestContext): Promise<void> {
-    try {
-      this.sendWs(ctx, createEnvelope(createOutputItemAddedEvent(ctx.responseId, ctx.itemId, 0)));
-    } catch (e) { this.logger.error("Failed to send item_added", e); }
-  }
-
-  private async generateDeltaEvent(ctx: RequestContext, text: string): Promise<void> {
-    try {
-      this.sendWs(ctx, createEnvelope(createOutputTextDeltaEvent(ctx.responseId, ctx.itemId, 0, text)));
-    } catch (e) { this.logger.error("Failed to send delta", e); }
-  }
-
-  private async generateContentPartDoneEvent(ctx: RequestContext): Promise<void> {
-    try {
-      this.sendWs(ctx, createEnvelope(createContentPartDoneEvent(ctx.responseId, ctx.itemId, 0)));
-    } catch (e) { this.logger.error("Failed to send content_part.done", e); }
-  }
-
-  private async generateCompletedEvent(ctx: RequestContext): Promise<void> {
-    try {
-      this.sendWs(ctx, createEnvelope(createCompletedEvent(ctx.responseId, ctx.sessionId)));
-    } catch (e) { this.logger.error("Failed to send completed", e); }
-  }
-
-  private async generateFailedEvent(ctx: RequestContext, code: string, message: string, details?: unknown): Promise<void> {
-    try {
-      this.sendWs(ctx, createEnvelope(createFailedEvent(ctx.responseId, code, message, details, ctx.sessionId)));
-    } catch (e) { this.logger.error("Failed to send failed event", e); }
-  }
-
-  private async handleChunk(ctx: RequestContext, chunk: string): Promise<void> {
-    try {
-      if (!ctx.firstChunkReceived) {
-        ctx.firstChunkReceived = true;
-        await this.generateInProgressEvent(ctx);
-        await this.generateItemAddedEvent(ctx);
-      }
-      ctx.responseBuffer += chunk;
-      await this.generateDeltaEvent(ctx, chunk);
-    } catch (e) { this.logger.error("Error handling chunk", e); }
-  }
-
-  private async handleCompletion(ctx: RequestContext): Promise<void> {
-    try {
-      // If the SDK produced no chunks at all (e.g. empty reply), still emit
-      // the protocol preamble so the client sees a well-formed response.
-      if (!ctx.firstChunkReceived) {
-        ctx.firstChunkReceived = true;
-        await this.generateInProgressEvent(ctx);
-        await this.generateItemAddedEvent(ctx);
-      }
-      await this.generateContentPartDoneEvent(ctx);
-      await this.generateCompletedEvent(ctx);
-      ctx.status = "completed";
-      this.logger.info("Request completed", {
-        messageId: ctx.messageId,
-        responseId: ctx.responseId,
-        duration: Date.now() - ctx.requestTimestamp,
-      });
-    } catch (e) {
-      this.logger.error("Error in handleCompletion", e);
-    } finally {
-      this.cleanupContext(ctx.messageId);
-    }
-  }
-
-  private async handleError(ctx: RequestContext, error: Error): Promise<void> {
-    try {
-      let code = "SDK_ERROR";
-      if (error.message.includes("timeout")) code = "TIMEOUT";
-      await this.generateFailedEvent(ctx, code, error.message, { stack: error.stack });
-      ctx.status = "failed";
-    } catch (e) {
-      this.logger.error("Error in handleError", e);
-    } finally {
-      this.cleanupContext(ctx.messageId);
-    }
-  }
-
-  private cleanupContext(messageId: string): void {
-    const ctx = this.contexts.get(messageId);
-    if (!ctx) return;
-    if (ctx.timeoutTimer) {
-      clearTimeout(ctx.timeoutTimer);
-      ctx.timeoutTimer = null;
-    }
-    ctx.abortController = null;
-    this.contexts.delete(messageId);
-  }
-}

package/src/channel/index.ts

@@ -1,173 +0,0 @@
-import type { ChannelPlugin } from "openclaw/plugin-sdk";
-import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
-import { CHANNEL_ID, DEBUG_ENABLED, POLL_INTERVAL_MS } from "./config.js";
-import { monitorProvider } from "./connection.js";
-import { triggerRegistrationAgent } from "./registrar.js";
-import { setBaseDir, isAgentRunning, getPendingRegistration } from "./registration-store.js";
-import { readProfile } from "../utils/profile.js";
-import { createEnvelope, textToEventSequence } from "./protocol.js";
-import { DebugLogger } from "./logger.js";
-
-// ── Active WS connections (accountId → WebSocket) ─────────────────────────────
-
-const activeConnections = new Map<string, import("ws").WebSocket>();
-
-export function registerConnection(accountId: string, ws: import("ws").WebSocket): void {
-  activeConnections.set(accountId || "default", ws);
-}
-
-export function unregisterConnection(accountId: string): void {
-  activeConnections.delete(accountId || "default");
-}
-
-// ── Plugin ────────────────────────────────────────────────────────────────────
-
-export const plugin: ChannelPlugin = {
-  id: CHANNEL_ID,
-
-  meta: {
-    id: CHANNEL_ID,
-    label: "InstaClaw",
-    selectionLabel: "InstaClaw",
-    docsPath: "/plugins/insta-plugin-openclaw",
-    blurb: "Instagram Claw Connector",
-  },
-
-  capabilities: {
-    chatTypes: ["direct"],
-    media: false,
-    polls: false,
-    threads: false,
-    reactions: false,
-    edit: false,
-    reply: false,
-  },
-
-  config: {
-    listAccountIds: (_cfg) => [DEFAULT_ACCOUNT_ID],
-
-    resolveAccount: (_cfg, accountId) => ({
-      accountId: accountId ?? DEFAULT_ACCOUNT_ID,
-    }),
-
-    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
-
-    isConfigured: (_account) => true,
-
-    describeAccount: (account) => ({
-      accountId: (account as { accountId: string }).accountId,
-    }),
-  },
-
-  gateway: {
-    startAccount: async (ctx) => {
-      const { cfg, accountId, abortSignal } = ctx;
-      const resolvedAccountId = accountId ?? DEFAULT_ACCOUNT_ID;
-
-      // Resolve base directory for local profile storage
-      const cfgAny = cfg as Record<string, unknown>;
-      const baseDir =
-        (cfgAny["agentDir"] as string | undefined) ??
-        (cfgAny["workspaceDir"] as string | undefined) ??
-        process.env["INSTA_BASE_DIR"] ??
-        process.cwd();
-
-      const logger = new DebugLogger(DEBUG_ENABLED, `[InstaPlugin:${resolvedAccountId}:startup]`);
-
-      // Bug 1 fix: cache the resolved baseDir so the gateway method
-      // (instaclaw.registration.submit) writes profile.json to the same path
-      // that this polling loop reads from.
-      setBaseDir(baseDir);
-
-      // Abort-aware sleep helper
-      const sleep = (ms: number) =>
-        new Promise<void>((resolve) => {
-          if (abortSignal.aborted) { resolve(); return; }
-          const t = setTimeout(resolve, ms);
-          abortSignal.addEventListener("abort", () => { clearTimeout(t); resolve(); }, { once: true });
-        });
-
-      logger.info("Gateway startup — entering credential polling loop", { baseDir, pollIntervalMs: POLL_INTERVAL_MS });
-
-      while (!abortSignal.aborted) {
-        const profile = await readProfile(baseDir).catch((err) => {
-          logger.error("Failed to read profile", err as Error);
-          return null;
-        });
-
-        const hasCredentials = !!(profile?.app_key && profile?.app_secret);
-
-        if (hasCredentials) {
-          logger.info("Credentials found, establishing WebSocket connection");
-          await monitorProvider(
-            { clientId: profile!.app_key, clientSecret: profile!.app_secret },
-            resolvedAccountId,
-            abortSignal,
-            ctx.channelRuntime,
-          );
-          // monitorProvider resolves when the connection is cleanly shut down (abort).
-          return;
-        }
-
-        // ── No credentials yet ────────────────────────────────────────────────
-        //
-        // Bug 2 fix: use store-based flags instead of a local boolean so the
-        // loop can recover if the agent completes without creating a proposal.
-        //
-        //  isAgentRunning()        → dispatch is in-flight, skip
-        //  getPendingRegistration() → proposal exists, wait for user, skip
-        //  neither                 → safe to trigger (first run OR recovery)
-        const agentRunning = isAgentRunning();
-        const hasPending   = !!getPendingRegistration();
-
-        logger.info("No credentials in profile — waiting for registration", {
-          profileExists: !!profile,
-          agentRunning,
-          hasPending,
-        });
-
-        if (!agentRunning && !hasPending) {
-          const result = await triggerRegistrationAgent(ctx.channelRuntime, cfg, logger, resolvedAccountId);
-          logger.info("Registration agent trigger result", { status: result.status, error: result.error });
-        }
-
-        await sleep(POLL_INTERVAL_MS);
-      }
-    },
-  },
-
-  outbound: {
-    deliveryMode: "gateway" as const,
-
-    sendText: async (ctx) => {
-      const { cfg, to, text, accountId } = ctx;
-      void cfg; // credentials are managed via gateway; cfg not needed here
-
-      if (!text?.trim()) {
-        throw new Error("Cannot send empty message");
-      }
-
-      const wsKey = accountId ?? DEFAULT_ACCOUNT_ID;
-      const ws = activeConnections.get(wsKey);
-
-      if (!ws) {
-        throw new Error(`WebSocket not found for account "${wsKey}". Gateway may not be connected.`);
-      }
-
-      if (ws.readyState !== 1 /* OPEN */) {
-        throw new Error(`WebSocket not open (state: ${ws.readyState}) for account "${wsKey}"`);
-      }
-
-      const events = textToEventSequence(text);
-      for (const event of events) {
-        ws.send(createEnvelope(event));
-      }
-
-      return {
-        channel: CHANNEL_ID,
-        messageId: `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
-        to,
-      };
-    },
-  },
-};

package/src/channel/logger.ts

@@ -1,36 +0,0 @@
-export class DebugLogger {
-  constructor(
-    private enabled: boolean,
-    private prefix: string = "[InstaPlugin]",
-  ) {}
-
-  info(message: string, ...args: unknown[]): void {
-    console.log(`${new Date().toISOString()} [INFO] ${this.prefix}`, message, ...args);
-  }
-
-  debug(message: string, ...args: unknown[]): void {
-    if (this.enabled) {
-      console.log(`${new Date().toISOString()} [DEBUG] ${this.prefix}`, message, ...args);
-    }
-  }
-
-  warn(message: string, ...args: unknown[]): void {
-    console.warn(`${new Date().toISOString()} [WARN] ${this.prefix}`, message, ...args);
-  }
-
-  error(message: string, errorOrContext?: unknown, ...args: unknown[]): void {
-    const ts = new Date().toISOString();
-    if (errorOrContext instanceof Error) {
-      console.error(
-        `${ts} [ERROR] ${this.prefix}`,
-        message,
-        "\nError:", errorOrContext.message,
-        "\nStack:", errorOrContext.stack,
-        ...args,
-      );
-    } else {
-      const tail = errorOrContext === undefined ? args : [errorOrContext, ...args];
-      console.error(`${ts} [ERROR] ${this.prefix}`, message, ...tail);
-    }
-  }
-}