npm - crom-agente-sdk - Versions diffs - 0.1.0 - Mend

crom-agente-sdk 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/__tests__/client.test.d.ts +1 -0
package/dist/client.d.ts +66 -0
package/dist/crom-agente-sdk.js +367 -0
package/dist/crom-agente-sdk.umd.cjs +1 -0
package/dist/index.d.ts +4 -0
package/dist/types.d.ts +120 -0
package/dist/utils.d.ts +5 -0
package/package.json +43 -0

package/dist/__tests__/client.test.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/client.d.ts ADDED Viewed

@@ -0,0 +1,66 @@
+export interface CromClientOptions {
+    daemonHost?: string;
+    daemonPort?: number;
+    cloudUrl?: string;
+    sessionToken?: string;
+    daemonToken?: string;
+    onTokenRefreshNeeded?: () => Promise<string | null>;
+    onWebSocketClose?: (event: CloseEvent) => void;
+    onWebSocketError?: (event: Event) => void;
+    WebSocketConstructor?: any;
+}
+export declare class CromClient {
+    private options;
+    private ws;
+    private reconnectTimer;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private baseReconnectDelay;
+    private listeners;
+    private wsUrl;
+    constructor(options?: CromClientOptions);
+    updateOptions(options: Partial<CromClientOptions>): void;
+    getOptions(): Required<CromClientOptions>;
+    on(event: string, callback: (data: any) => void): () => void;
+    off(event: string, callback: (data: any) => void): void;
+    private emit;
+    buildDaemonUrl(path: string, params?: Record<string, string>): string;
+    private buildCloudUrl;
+    private getCloudHeaders;
+    getDaemonToken(): Promise<string>;
+    getSystemInfo(): Promise<any>;
+    getTags(): Promise<any>;
+    getTerminals(): Promise<any>;
+    closeTerminal(terminalId: string): Promise<any>;
+    stopDaemon(workspace?: string): Promise<any>;
+    getScheduledTasks(): Promise<any[]>;
+    addScheduledTask(task: {
+        name: string;
+        cron: string;
+        workspace: string;
+        task: string;
+    }): Promise<any>;
+    deleteScheduledTask(id: string): Promise<any>;
+    runScheduledTask(id: string): Promise<any>;
+    getScreenDevices(): Promise<any>;
+    getAudioDevices(): Promise<any>;
+    startRecording(type: "audio" | "screen", params?: Record<string, string>): Promise<any>;
+    stopRecording(type: "audio" | "screen"): Promise<Blob>;
+    transcribeAudio(audioBlob: Blob): Promise<{
+        text: string;
+    }>;
+    listFiles(dirPath: string): Promise<any[]>;
+    readFile(filePath: string): Promise<string>;
+    writeFile(filePath: string, content: string, encoding?: string): Promise<any>;
+    getCloudUser(): Promise<any>;
+    getCloudModels(): Promise<any>;
+    getLatestRelease(repo?: string): Promise<any>;
+    getOpenRouterModels(): Promise<any>;
+    connectWebSocket(workspacePath: string, activeSessionId?: string, initialPrompt?: string, defaultProvider?: string, defaultModel?: string): void;
+    private scheduleReconnect;
+    disconnectWebSocket(): void;
+    sendRun(workspacePath: string, sessionId: string, task: string, provider?: string, model?: string, autoApprove?: boolean): void;
+    sendStop(workspacePath: string): void;
+    sendAutoApprove(workspacePath: string, enabled: boolean): void;
+    sendPermissionResponse(workspacePath: string, approved: boolean): void;
+}

package/dist/crom-agente-sdk.js ADDED Viewed

@@ -0,0 +1,367 @@
+var g = Object.defineProperty;
+var S = (s, e, t) => e in s ? g(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var u = (s, e, t) => S(s, typeof e != "symbol" ? e + "" : e, t);
+function A(s) {
+  return s && typeof s.event == "string" && typeof s.timestamp == "string";
+}
+function U(s) {
+  return s && typeof s.type == "string" && !s.event;
+}
+const $ = {
+  ERR_LLM_RATE_LIMIT: "Aguarde o cooldown ou troque de provedor/chave.",
+  ERR_LLM_AUTHENTICATION: "Verifique e atualize sua chave de API nas configurações.",
+  ERR_LLM_EMPTY_RESPONSE: "O modelo retornou vazio. Tente novamente ou troque de modelo.",
+  ERR_TOOL_NOT_FOUND: "Ferramenta não registrada. Verifique as ferramentas disponíveis.",
+  ERR_TOOL_EXECUTION: "Erro na execução da ferramenta. Verifique os logs.",
+  ERR_TOOL_TIMEOUT: "A ferramenta excedeu o tempo limite. Aumente o timeout ou simplifique a operação.",
+  ERR_PERMISSION_DENIED: "A ação foi rejeitada. Altere as permissões ou aprove manualmente.",
+  ERR_SANDBOX_VIOLATION: "Tentativa de acessar recurso fora do sandbox do workspace.",
+  ERR_MAX_ITERATIONS: "O agente atingiu o limite de iterações. Aumente o limite ou simplifique a tarefa.",
+  ERR_CONSECUTIVE_FAILURES: "Muitas falhas consecutivas. Verifique a configuração e os logs.",
+  ERR_CONTEXT_CANCELED: "A execução foi cancelada pelo usuário ou pelo sistema."
+};
+function R(s) {
+  if (!s) return null;
+  if (typeof s == "string")
+    try {
+      return JSON.parse(s);
+    } catch {
+      return s;
+    }
+  if (typeof s == "object" && !Array.isArray(s)) {
+    const e = Object.keys(s);
+    if (!(e.length > 0 && e.every((o) => !isNaN(Number(o)))))
+      return s;
+    try {
+      const o = new Uint8Array(Object.values(s)), r = new TextDecoder().decode(o);
+      return JSON.parse(r);
+    } catch {
+      return s;
+    }
+  }
+  return s;
+}
+class v {
+  constructor(e = {}) {
+    u(this, "options");
+    u(this, "ws", null);
+    u(this, "reconnectTimer", null);
+    u(this, "reconnectAttempts", 0);
+    u(this, "maxReconnectAttempts", 5);
+    u(this, "baseReconnectDelay", 2e3);
+    u(this, "listeners", /* @__PURE__ */ new Map());
+    u(this, "wsUrl", "");
+    this.options = {
+      daemonHost: e.daemonHost || "127.0.0.1",
+      daemonPort: e.daemonPort || 9090,
+      cloudUrl: e.cloudUrl || "https://cloud.ia.crom.run",
+      sessionToken: e.sessionToken || "",
+      daemonToken: e.daemonToken || "",
+      onTokenRefreshNeeded: e.onTokenRefreshNeeded || (async () => null),
+      onWebSocketClose: e.onWebSocketClose || (() => {
+      }),
+      onWebSocketError: e.onWebSocketError || (() => {
+      }),
+      WebSocketConstructor: e.WebSocketConstructor || null
+    };
+  }
+  updateOptions(e) {
+    this.options = { ...this.options, ...e };
+  }
+  getOptions() {
+    return this.options;
+  }
+  // --- Listener management ---
+  on(e, t) {
+    return this.listeners.has(e) || this.listeners.set(e, /* @__PURE__ */ new Set()), this.listeners.get(e).add(t), () => this.off(e, t);
+  }
+  off(e, t) {
+    const o = this.listeners.get(e);
+    o && o.delete(t);
+  }
+  emit(e, t) {
+    const o = this.listeners.get(e);
+    if (o)
+      for (const r of o)
+        try {
+          r(t);
+        } catch (i) {
+          console.error("Error in CromClient event listener:", i);
+        }
+  }
+  // --- HTTP Helpers ---
+  buildDaemonUrl(e, t = {}) {
+    const o = this.options.daemonHost, r = this.options.daemonPort, i = new URL(`http://${o}:${r}${e}`), d = this.options.daemonToken || this.options.sessionToken;
+    d && i.searchParams.set("token", d);
+    for (const [w, p] of Object.entries(t))
+      p != null && i.searchParams.set(w, p);
+    return i.toString();
+  }
+  buildCloudUrl(e) {
+    return `${this.options.cloudUrl.replace(/\/$/, "")}${e}`;
+  }
+  getCloudHeaders() {
+    const e = {};
+    return this.options.sessionToken && (e.Authorization = `Bearer ${this.options.sessionToken}`), e;
+  }
+  // --- HTTP REST API methods ---
+  async getDaemonToken() {
+    const e = `http://${this.options.daemonHost}:${this.options.daemonPort}/api/token`, t = await fetch(e);
+    if (!t.ok) throw new Error(`Failed to fetch daemon token: ${t.statusText}`);
+    const o = await t.json();
+    if (o && o.token)
+      return this.options.daemonToken = o.token, o.token;
+    throw new Error("No token returned from daemon");
+  }
+  async getSystemInfo() {
+    const e = this.buildDaemonUrl("/api/system/info"), t = await fetch(e);
+    if (!t.ok) throw new Error(`Failed to fetch system info: ${t.statusText}`);
+    return t.json();
+  }
+  async getTags() {
+    const e = this.buildDaemonUrl("/api/tags"), t = await fetch(e);
+    if (!t.ok) throw new Error(`Failed to fetch tags: ${t.statusText}`);
+    return t.json();
+  }
+  async getTerminals() {
+    const e = this.buildDaemonUrl("/api/terminal/list"), t = await fetch(e);
+    if (!t.ok) throw new Error(`Failed to fetch terminal list: ${t.statusText}`);
+    return t.json();
+  }
+  async closeTerminal(e) {
+    const t = this.buildDaemonUrl("/api/terminal/close", { id: e }), o = await fetch(t, {
+      method: "POST"
+    });
+    if (!o.ok) throw new Error(`Failed to close terminal: ${o.statusText}`);
+    return o.json();
+  }
+  async stopDaemon(e) {
+    const t = this.buildDaemonUrl("/stop"), o = e ? JSON.stringify({ workspace: e }) : void 0, r = await fetch(t, {
+      method: "POST",
+      headers: o ? { "Content-Type": "application/json" } : {},
+      body: o
+    });
+    if (!r.ok) throw new Error(`Failed to stop daemon: ${r.statusText}`);
+    return r.json();
+  }
+  async getScheduledTasks() {
+    const e = this.buildDaemonUrl("/api/schedule"), t = await fetch(e);
+    if (!t.ok) throw new Error(`Failed to fetch scheduled tasks: ${t.statusText}`);
+    return t.json();
+  }
+  async addScheduledTask(e) {
+    const t = this.buildDaemonUrl("/api/schedule"), o = await fetch(t, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(e)
+    });
+    if (!o.ok) throw new Error(`Failed to add scheduled task: ${o.statusText}`);
+    return o.json();
+  }
+  async deleteScheduledTask(e) {
+    const t = this.buildDaemonUrl("/api/schedule", { id: e }), o = await fetch(t, { method: "DELETE" });
+    if (!o.ok) throw new Error(`Failed to delete scheduled task: ${o.statusText}`);
+    return o.json();
+  }
+  async runScheduledTask(e) {
+    const t = this.buildDaemonUrl("/api/schedule/run", { id: e }), o = await fetch(t, { method: "POST" });
+    if (!o.ok) throw new Error(`Failed to run scheduled task: ${o.statusText}`);
+    return o.json();
+  }
+  async getScreenDevices() {
+    const e = this.buildDaemonUrl("/api/devices/screens"), t = await fetch(e);
+    if (!t.ok) throw new Error(`Failed to fetch screen devices: ${t.statusText}`);
+    return t.json();
+  }
+  async getAudioDevices() {
+    const e = this.buildDaemonUrl("/api/devices/audio"), t = await fetch(e);
+    if (!t.ok) throw new Error(`Failed to fetch audio devices: ${t.statusText}`);
+    return t.json();
+  }
+  async startRecording(e, t = {}) {
+    const o = this.buildDaemonUrl("/api/record/start", { type: e, ...t }), r = await fetch(o);
+    if (!r.ok) throw new Error(`Failed to start recording: ${r.statusText}`);
+    return r.json();
+  }
+  async stopRecording(e) {
+    const t = this.buildDaemonUrl("/api/record/stop", { type: e }), o = await fetch(t);
+    if (!o.ok) throw new Error(`Failed to stop recording: ${o.statusText}`);
+    return o.blob();
+  }
+  async transcribeAudio(e) {
+    const t = this.buildDaemonUrl("/api/transcribe"), o = await fetch(t, {
+      method: "POST",
+      body: e,
+      headers: {
+        "Content-Type": "audio/wav"
+      }
+    });
+    if (!o.ok) throw new Error(`Failed to transcribe audio: ${o.statusText}`);
+    return o.json();
+  }
+  // --- Filesystem API methods ---
+  async listFiles(e) {
+    const t = this.buildDaemonUrl("/api/files", { path: e }), o = await fetch(t);
+    if (!o.ok) throw new Error(`Failed to list files: ${o.statusText}`);
+    return o.json();
+  }
+  async readFile(e) {
+    const t = this.buildDaemonUrl("/api/file", { path: e }), o = await fetch(t);
+    if (!o.ok) throw new Error(`Failed to read file: ${o.statusText}`);
+    return o.text();
+  }
+  async writeFile(e, t, o) {
+    const r = this.buildDaemonUrl("/api/file"), i = await fetch(r, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        path: e,
+        content: t,
+        encoding: o
+      })
+    });
+    if (!i.ok) throw new Error(`Failed to write file: ${i.statusText}`);
+    return i.json();
+  }
+  // --- Cloud & Models REST API ---
+  async getCloudUser() {
+    const e = this.buildCloudUrl("/api/v1/admin/me"), t = await fetch(e, {
+      headers: this.getCloudHeaders()
+    });
+    if (!t.ok) throw new Error(`Failed to fetch cloud user: ${t.statusText}`);
+    return t.json();
+  }
+  async getCloudModels() {
+    const e = this.buildCloudUrl("/api/v1/models"), t = await fetch(e, {
+      headers: this.getCloudHeaders()
+    });
+    if (!t.ok) throw new Error(`Failed to fetch cloud models: ${t.statusText}`);
+    return t.json();
+  }
+  async getLatestRelease(e = "crom-agente") {
+    const t = this.buildCloudUrl(`/api/v1/github/releases?repo=${e}`), o = await fetch(t);
+    if (!o.ok) throw new Error(`Failed to fetch latest release: ${o.statusText}`);
+    return o.json();
+  }
+  async getOpenRouterModels() {
+    const t = await fetch("https://openrouter.ai/api/v1/models");
+    if (!t.ok) throw new Error(`Failed to fetch OpenRouter models: ${t.statusText}`);
+    return t.json();
+  }
+  // --- WebSocket Connection ---
+  connectWebSocket(e, t, o, r, i) {
+    var E;
+    this.disconnectWebSocket();
+    const d = this.options.daemonHost, w = this.options.daemonPort, p = this.options.sessionToken || this.options.daemonToken, y = `${typeof window < "u" && ((E = window.location) == null ? void 0 : E.protocol) === "https:" ? "wss:" : "ws:"}//${d}:${w}/ws${p ? `?token=${encodeURIComponent(p)}` : ""}`;
+    this.wsUrl = y;
+    const k = this.options.WebSocketConstructor || (typeof window < "u" ? window.WebSocket : null);
+    if (!k)
+      throw new Error("No WebSocket constructor available. Pass one in options for Node environment.");
+    const h = new k(y);
+    this.ws = h, h.onopen = () => {
+      this.reconnectAttempts = 0, this.emit("open", { url: y }), h.send(JSON.stringify({ type: "subscribe", workspace: e }));
+      const c = typeof localStorage < "u" ? localStorage.getItem("crom_auto_approve_enabled") === "true" : !1;
+      h.send(JSON.stringify({ type: "set_auto_approve", workspace: e, auto_approve: c })), o && o.trim() && (h.send(JSON.stringify({
+        type: "run",
+        workspace: e,
+        session: t,
+        task: o,
+        provider: r,
+        model: i
+      })), this.emit("prompt_sent", { prompt: o }));
+    }, h.onmessage = (c) => {
+      try {
+        const a = R(c.data);
+        if (!a) return;
+        const m = Array.isArray(a) ? a : [a];
+        for (const T of m) {
+          let n = T.data;
+          if (typeof n == "string")
+            try {
+              n = JSON.parse(n);
+            } catch {
+            }
+          let l = "", b = 0, f = null;
+          if (n && typeof n == "object" && ("event" in n ? (l = n.event, b = n.iteration || 0, f = n.data) : "type" in n && (n.type === "status" ? (l = "status_change", f = { status: n.status }) : n.type === "ask_permission" ? (l = "permission_request", f = { action: n.action, target: n.target }) : n.type === "message" ? (l = "message", f = n) : (l = n.type, f = n))), !l)
+            if (T.error)
+              l = "error", f = { error: { code: "ERR_DAEMON", message: T.error } };
+            else
+              continue;
+          this.emit(l, {
+            event: l,
+            iteration: b,
+            data: f
+          });
+        }
+      } catch (a) {
+        this.emit("error", { error: a });
+      }
+    }, h.onerror = (c) => {
+      this.emit("error", { error: c }), this.options.onWebSocketError && this.options.onWebSocketError(c);
+    }, h.onclose = (c) => {
+      if (this.emit("close", c), this.options.onWebSocketClose && this.options.onWebSocketClose(c), this.reconnectAttempts < this.maxReconnectAttempts) {
+        const a = this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts);
+        this.reconnectAttempts += 1, this.options.onTokenRefreshNeeded ? this.options.onTokenRefreshNeeded().then((m) => {
+          m && (this.options.sessionToken = m), this.scheduleReconnect(e, t, o, r, i, a);
+        }).catch(() => {
+          this.scheduleReconnect(e, t, o, r, i, a);
+        }) : this.scheduleReconnect(e, t, o, r, i, a);
+      }
+    };
+  }
+  scheduleReconnect(e, t, o, r, i, d = 2e3) {
+    this.reconnectTimer && clearTimeout(this.reconnectTimer), this.reconnectTimer = setTimeout(() => {
+      this.connectWebSocket(e, t, o, r, i);
+    }, d);
+  }
+  disconnectWebSocket() {
+    this.reconnectTimer && (clearTimeout(this.reconnectTimer), this.reconnectTimer = null), this.ws && (this.ws.onopen = null, this.ws.onmessage = null, this.ws.onerror = null, this.ws.onclose = null, this.ws.close(), this.ws = null);
+  }
+  sendRun(e, t, o, r, i, d) {
+    if (!this.ws || this.ws.readyState !== 1) throw new Error("WebSocket not connected");
+    this.ws.send(JSON.stringify({
+      type: "run",
+      workspace: e,
+      session: t,
+      task: o,
+      provider: r,
+      model: i,
+      auto_approve: d
+    }));
+  }
+  sendStop(e) {
+    if (!this.ws || this.ws.readyState !== 1) throw new Error("WebSocket not connected");
+    this.ws.send(JSON.stringify({
+      type: "stop",
+      workspace: e
+    }));
+  }
+  sendAutoApprove(e, t) {
+    if (!this.ws || this.ws.readyState !== 1) throw new Error("WebSocket not connected");
+    this.ws.send(JSON.stringify({
+      type: "set_auto_approve",
+      workspace: e,
+      auto_approve: t
+    }));
+  }
+  sendPermissionResponse(e, t) {
+    if (!this.ws || this.ws.readyState !== 1) throw new Error("WebSocket not connected");
+    this.ws.send(JSON.stringify({
+      type: "permission_response",
+      workspace: e,
+      payload: {
+        approved: t,
+        remember: !1
+      }
+    }));
+  }
+}
+export {
+  v as CromClient,
+  $ as ERROR_ACTIONS,
+  A as isAgentEvent,
+  U as isLegacyEvent,
+  R as parseDaemonPayload
+};

package/dist/crom-agente-sdk.umd.cjs ADDED Viewed

@@ -0,0 +1 @@

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./utils.js";
+export * from "./client.js";
+export { ERROR_ACTIONS } from "./types.js";

package/dist/types.d.ts ADDED Viewed

@@ -0,0 +1,120 @@
+/**
+ * crom-agente SDK — Tipos do Protocolo de Eventos Estruturados
+ *
+ * Estes tipos definem o protocolo JSON que o daemon do crom-agente emite via WebSocket/IPC.
+ * Use-os para consumir eventos do agente de forma tipada em qualquer aplicação TypeScript.
+ */
+/** Tipos de evento possíveis emitidos pelo AgenticLoop */
+export type AgentEventType = "thinking" | "message" | "tool_call" | "tool_result" | "error" | "finished";
+/** Evento estruturado emitido pelo agente em tempo real */
+export interface AgentEvent {
+    /** Timestamp ISO 8601 do momento da emissão */
+    timestamp: string;
+    /** Tipo do evento */
+    event: AgentEventType;
+    /** Número da iteração atual do loop ReAct (1-indexed) */
+    iteration?: number;
+    /** Dados específicos do evento */
+    data?: Record<string, any>;
+}
+/** Dados do evento "thinking" */
+export interface ThinkingEventData {
+    provider: string;
+    model: string;
+}
+/** Dados do evento "message" */
+export interface MessageEventData {
+    role: "assistant" | "system" | "user" | "tool";
+    content: string;
+    usage: TokenUsage;
+    has_tool_calls: boolean;
+}
+/** Dados do evento "tool_call" */
+export interface ToolCallEventData {
+    tool_call_id: string;
+    tool: string;
+    arguments: Record<string, any>;
+}
+/** Dados do evento "tool_result" */
+export interface ToolResultEventData {
+    tool_call_id: string;
+    tool: string;
+    success: boolean;
+    output?: string;
+    error?: string;
+    error_code?: AgentErrorCode;
+}
+/** Dados do evento "error" */
+export interface ErrorEventData {
+    error: AgentError;
+}
+/** Dados do evento "finished" */
+export interface FinishedEventData {
+    reason: "completed" | "max_iterations" | "consecutive_failures" | "canceled";
+    total_iterations: number;
+}
+/** Erro tipado emitido pelo agente para tratamento programático */
+export interface AgentError {
+    /** Código identificador do erro */
+    code: AgentErrorCode;
+    /** Mensagem legível do erro */
+    message: string;
+    /** Detalhes adicionais específicos do erro */
+    details?: Record<string, any>;
+}
+/** Códigos de erro padronizados do agente */
+export type AgentErrorCode = "ERR_LLM_RATE_LIMIT" | "ERR_LLM_AUTHENTICATION" | "ERR_LLM_EMPTY_RESPONSE" | "ERR_TOOL_NOT_FOUND" | "ERR_TOOL_EXECUTION" | "ERR_TOOL_TIMEOUT" | "ERR_PERMISSION_DENIED" | "ERR_SANDBOX_VIOLATION" | "ERR_MAX_ITERATIONS" | "ERR_CONSECUTIVE_FAILURES" | "ERR_CONTEXT_CANCELED";
+/** Informações de consumo de tokens de uma chamada ao LLM */
+export interface TokenUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+/** Estado atual de um servidor MCP */
+export interface MCPServerStatus {
+    name: string;
+    mode: "subprocess" | "sse";
+    tool_count: number;
+    tools: string[];
+    running: boolean;
+}
+/** Mensagem enviada pelo cliente ao daemon */
+export interface IPCMessage {
+    type: "run" | "status" | "stop" | "ping" | "subscribe" | "permission_response";
+    workspace?: string;
+    task?: string;
+    session?: string;
+    payload?: any;
+}
+/** Resposta enviada pelo daemon ao cliente */
+export interface IPCResponse {
+    success: boolean;
+    data?: AgentEvent | LegacyEvent;
+    error?: string;
+    stream: boolean;
+}
+/** Evento legado de status */
+export interface LegacyStatusEvent {
+    type: "status";
+    status: string;
+}
+/** Evento legado de mensagem */
+export interface LegacyMessageEvent {
+    type: "message";
+    role: string;
+    content: string;
+}
+/** Evento legado de permissão */
+export interface LegacyPermissionEvent {
+    type: "ask_permission";
+    action: string;
+    target: string;
+}
+/** União de todos os eventos legados */
+export type LegacyEvent = LegacyStatusEvent | LegacyMessageEvent | LegacyPermissionEvent;
+/** Type guard para verificar se um payload é um AgentEvent estruturado */
+export declare function isAgentEvent(data: any): data is AgentEvent;
+/** Type guard para verificar se um payload é um evento legado */
+export declare function isLegacyEvent(data: any): data is LegacyEvent;
+/** Tabela de ações recomendadas para cada código de erro */
+export declare const ERROR_ACTIONS: Record<AgentErrorCode, string>;

package/dist/utils.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+/**
+ * Decodifica e faz o parsing de dados recebidos pelo daemon.
+ * Lida com strings JSON normais e também com objetos Uint8Array serializados.
+ */
+export declare function parseDaemonPayload(responseData: any): any;

package/package.json ADDED Viewed

@@ -0,0 +1,43 @@
+{
+  "name": "crom-agente-sdk",
+  "version": "0.1.0",
+  "description": "SDK oficial em TypeScript para integração com o ecossistema crom-agente",
+  "type": "module",
+  "main": "./dist/crom-agente-sdk.umd.cjs",
+  "module": "./dist/crom-agente-sdk.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/crom-agente-sdk.js",
+      "require": "./dist/crom-agente-sdk.umd.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "vite build && tsc --emitDeclarationOnly",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "crom",
+    "agente",
+    "sdk",
+    "typescript"
+  ],
+  "author": "CromIA",
+  "license": "CUSTOM",
+  "devDependencies": {
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.3.3",
+    "vite": "^5.1.4",
+    "vite-plugin-dts": "^3.7.3",
+    "vitest": "^1.3.1"
+  },
+  "dependencies": {
+    "axios": "^1.18.0",
+    "ws": "^8.21.0"
+  }
+}