@almadar/integrations 1.0.15 → 2.0.1

package/dist/index.js

@@ -1460,6 +1460,1229 @@ var CLIIntegration = class extends BaseIntegration {
 };
 registerIntegration("cli", CLIIntegration);
 
-export { BaseIntegration, CLIIntegration, ConsoleLogger, DeepAgentIntegration, EmailIntegration, GitHubIntegration, IntegrationFactory, LLMIntegration, StripeIntegration, TwilioIntegration, YouTubeIntegration, getIntegration, getRegisteredIntegrations, isKnownIntegration, registerIntegration, validateParams, withRetry };
+// src/integrations/redis/index.ts
+var RedisIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    this.store = /* @__PURE__ */ new Map();
+    this.locks = /* @__PURE__ */ new Map();
+    this.channels = /* @__PURE__ */ new Map();
+    const redisUrl = config.env.REDIS_URL;
+    if (redisUrl) {
+      this.logger.warn(
+        "REDIS_URL is configured but real Redis client is not yet implemented. Falling back to in-memory store.",
+        { redisUrl }
+      );
+    }
+    this.logger.info("Redis integration initialized (in-memory backend)");
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    try {
+      let data;
+      switch (action) {
+        case "get":
+          data = await this.executeWithRetry(() => this.getKey(params));
+          break;
+        case "set":
+          data = await this.executeWithRetry(() => this.setKey(params));
+          break;
+        case "delete":
+          data = await this.executeWithRetry(() => this.deleteKey(params));
+          break;
+        case "lock":
+          data = await this.executeWithRetry(() => this.acquireLock(params));
+          break;
+        case "unlock":
+          data = await this.executeWithRetry(() => this.releaseLock(params));
+          break;
+        case "increment":
+          data = await this.executeWithRetry(() => this.incrementKey(params));
+          break;
+        case "expire":
+          data = await this.executeWithRetry(() => this.expireKey(params));
+          break;
+        case "publish":
+          data = await this.executeWithRetry(() => this.publishMessage(params));
+          break;
+        case "subscribe":
+          data = await this.executeWithRetry(
+            () => this.subscribeChannel(params)
+          );
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return {
+        success: true,
+        data,
+        metadata: this.createMetadata(action, Date.now() - startTime)
+      };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  /** Remove expired entries on access and return whether a key is alive. */
+  isAlive(key) {
+    const entry = this.store.get(key);
+    if (!entry) return false;
+    if (entry.expiresAt !== void 0 && Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /** Generate a unique lock identifier. */
+  generateLockId() {
+    return `lock_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+  }
+  // ---------------------------------------------------------------------------
+  // Actions
+  // ---------------------------------------------------------------------------
+  async getKey(params) {
+    const key = params.key;
+    this.logger.debug("Cache GET", { key });
+    if (!this.isAlive(key)) {
+      return { value: null };
+    }
+    const entry = this.store.get(key);
+    return { value: entry ? entry.value : null };
+  }
+  async setKey(params) {
+    const key = params.key;
+    const value = params.value;
+    const ttl = params.ttl;
+    this.logger.debug("Cache SET", { key, ttl });
+    const entry = { value };
+    if (ttl !== void 0 && ttl > 0) {
+      entry.expiresAt = Date.now() + ttl * 1e3;
+    }
+    this.store.set(key, entry);
+    return { ok: true };
+  }
+  async deleteKey(params) {
+    const key = params.key;
+    this.logger.debug("Cache DELETE", { key });
+    const existed = this.store.has(key);
+    this.store.delete(key);
+    return { deleted: existed };
+  }
+  async acquireLock(params) {
+    const key = params.key;
+    const ttl = params.ttl ?? 3e4;
+    this.logger.debug("Cache LOCK", { key, ttl });
+    const existingLockId = this.locks.get(key);
+    if (existingLockId) {
+      if (this.isAlive(`__lock:${key}`)) {
+        return { acquired: false, lockId: "" };
+      }
+      this.locks.delete(key);
+      this.store.delete(`__lock:${key}`);
+    }
+    const lockId = this.generateLockId();
+    this.locks.set(key, lockId);
+    this.store.set(`__lock:${key}`, {
+      value: lockId,
+      expiresAt: Date.now() + ttl
+    });
+    return { acquired: true, lockId };
+  }
+  async releaseLock(params) {
+    const key = params.key;
+    const lockId = params.lockId;
+    this.logger.debug("Cache UNLOCK", { key, lockId });
+    const currentLockId = this.locks.get(key);
+    if (currentLockId !== lockId) {
+      return { released: false };
+    }
+    this.locks.delete(key);
+    this.store.delete(`__lock:${key}`);
+    return { released: true };
+  }
+  async incrementKey(params) {
+    const key = params.key;
+    const by = params.by ?? 1;
+    this.logger.debug("Cache INCR", { key, by });
+    let current = 0;
+    if (this.isAlive(key)) {
+      const entry = this.store.get(key);
+      if (entry) {
+        current = typeof entry.value === "number" ? entry.value : 0;
+      }
+    }
+    const newValue = current + by;
+    const existing = this.store.get(key);
+    this.store.set(key, {
+      value: newValue,
+      expiresAt: existing?.expiresAt
+    });
+    return { value: newValue };
+  }
+  async expireKey(params) {
+    const key = params.key;
+    const ttl = params.ttl;
+    this.logger.debug("Cache EXPIRE", { key, ttl });
+    if (!this.isAlive(key)) {
+      return { set: false };
+    }
+    const entry = this.store.get(key);
+    if (!entry) {
+      return { set: false };
+    }
+    entry.expiresAt = Date.now() + ttl * 1e3;
+    this.store.set(key, entry);
+    return { set: true };
+  }
+  async publishMessage(params) {
+    const channel = params.channel;
+    const message = params.message;
+    this.logger.debug("Cache PUBLISH", { channel });
+    const subscribers = this.channels.get(channel);
+    if (!subscribers || subscribers.size === 0) {
+      return { receivers: 0 };
+    }
+    for (const callback of subscribers) {
+      try {
+        callback(message);
+      } catch (err) {
+        this.logger.error("Subscriber callback error", {
+          channel,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    return { receivers: subscribers.size };
+  }
+  async subscribeChannel(params) {
+    const channel = params.channel;
+    this.logger.debug("Cache SUBSCRIBE", { channel });
+    if (!this.channels.has(channel)) {
+      this.channels.set(channel, /* @__PURE__ */ new Set());
+    }
+    return { subscribed: true };
+  }
+};
+registerIntegration("redis", RedisIntegration);
+
+// src/integrations/queue/index.ts
+var QueueIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    /** Map from queue name to ordered list of job IDs */
+    this.queues = /* @__PURE__ */ new Map();
+    /** Map from job ID to job data */
+    this.jobs = /* @__PURE__ */ new Map();
+    this.logger.info("Queue integration initialized (in-memory backend)");
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    try {
+      let data;
+      switch (action) {
+        case "enqueue":
+          data = await this.executeWithRetry(() => this.enqueue(params));
+          break;
+        case "dequeue":
+          data = await this.executeWithRetry(() => this.dequeue(params));
+          break;
+        case "status":
+          data = await this.executeWithRetry(() => this.status(params));
+          break;
+        case "complete":
+          data = await this.executeWithRetry(() => this.complete(params));
+          break;
+        case "fail":
+          data = await this.executeWithRetry(() => this.failJob(params));
+          break;
+        case "cancel":
+          data = await this.executeWithRetry(() => this.cancel(params));
+          break;
+        case "size":
+          data = await this.executeWithRetry(() => this.size(params));
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return {
+        success: true,
+        data,
+        metadata: this.createMetadata(action, Date.now() - startTime)
+      };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  /** Generate a unique job identifier. */
+  generateJobId() {
+    return `job_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  }
+  /** Get or create the queue array for a given queue name. */
+  getQueue(name) {
+    let queue = this.queues.get(name);
+    if (!queue) {
+      queue = [];
+      this.queues.set(name, queue);
+    }
+    return queue;
+  }
+  // ---------------------------------------------------------------------------
+  // Actions
+  // ---------------------------------------------------------------------------
+  async enqueue(params) {
+    const queueName = params.queue;
+    const payload = params.payload;
+    const delay = params.delay ?? 0;
+    const priority = params.priority ?? 0;
+    this.logger.debug("Queue ENQUEUE", { queue: queueName, delay, priority });
+    const jobId = this.generateJobId();
+    const job = {
+      id: jobId,
+      queue: queueName,
+      payload,
+      priority,
+      status: "pending",
+      enqueuedAt: Date.now(),
+      delay
+    };
+    this.jobs.set(jobId, job);
+    const queue = this.getQueue(queueName);
+    let insertIndex = queue.length;
+    for (let i = 0; i < queue.length; i++) {
+      const existingJob = this.jobs.get(queue[i]);
+      if (existingJob && existingJob.priority < priority) {
+        insertIndex = i;
+        break;
+      }
+    }
+    queue.splice(insertIndex, 0, jobId);
+    return { jobId, position: insertIndex };
+  }
+  async dequeue(params) {
+    const queueName = params.queue;
+    this.logger.debug("Queue DEQUEUE", { queue: queueName });
+    const queue = this.getQueue(queueName);
+    const now = Date.now();
+    for (let i = 0; i < queue.length; i++) {
+      const job = this.jobs.get(queue[i]);
+      if (!job || job.status !== "pending") continue;
+      const readyAt = job.enqueuedAt + job.delay;
+      if (now < readyAt) continue;
+      job.status = "processing";
+      queue.splice(i, 1);
+      return {
+        job: {
+          id: job.id,
+          payload: job.payload,
+          enqueuedAt: job.enqueuedAt,
+          priority: job.priority
+        }
+      };
+    }
+    return { job: null };
+  }
+  async status(params) {
+    const jobId = params.jobId;
+    this.logger.debug("Queue STATUS", { jobId });
+    const job = this.jobs.get(jobId);
+    if (!job) {
+      return { status: "pending", job: null };
+    }
+    return {
+      status: job.status,
+      job: {
+        id: job.id,
+        payload: job.payload,
+        enqueuedAt: job.enqueuedAt,
+        priority: job.priority
+      }
+    };
+  }
+  async complete(params) {
+    const jobId = params.jobId;
+    const result = params.result;
+    this.logger.debug("Queue COMPLETE", { jobId });
+    const job = this.jobs.get(jobId);
+    if (!job || job.status !== "processing") {
+      return { completed: false };
+    }
+    job.status = "completed";
+    job.result = result;
+    return { completed: true };
+  }
+  async failJob(params) {
+    const jobId = params.jobId;
+    const error = params.error;
+    this.logger.debug("Queue FAIL", { jobId });
+    const job = this.jobs.get(jobId);
+    if (!job || job.status !== "processing") {
+      return { failed: false };
+    }
+    job.status = "failed";
+    job.error = error;
+    return { failed: true };
+  }
+  async cancel(params) {
+    const jobId = params.jobId;
+    this.logger.debug("Queue CANCEL", { jobId });
+    const job = this.jobs.get(jobId);
+    if (!job || job.status !== "pending") {
+      return { cancelled: false };
+    }
+    const queue = this.queues.get(job.queue);
+    if (queue) {
+      const idx = queue.indexOf(jobId);
+      if (idx !== -1) {
+        queue.splice(idx, 1);
+      }
+    }
+    this.jobs.delete(jobId);
+    return { cancelled: true };
+  }
+  async size(params) {
+    const queueName = params.queue;
+    this.logger.debug("Queue SIZE", { queue: queueName });
+    let pending = 0;
+    let processing = 0;
+    for (const job of this.jobs.values()) {
+      if (job.queue !== queueName) continue;
+      if (job.status === "pending") pending++;
+      if (job.status === "processing") processing++;
+    }
+    return { size: pending + processing, pending, processing };
+  }
+};
+registerIntegration("queue", QueueIntegration);
+
+// src/integrations/otel/index.ts
+function randomHexId(bytes) {
+  const arr = [];
+  for (let i = 0; i < bytes; i++) {
+    arr.push(Math.floor(Math.random() * 256).toString(16).padStart(2, "0"));
+  }
+  return arr.join("");
+}
+var OtelIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    this.spans = /* @__PURE__ */ new Map();
+    this.metrics = /* @__PURE__ */ new Map();
+    this.logger.info("OTel integration initialized (in-memory backend)");
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    try {
+      let data;
+      switch (action) {
+        case "startSpan":
+          data = await this.executeWithRetry(() => this.startSpan(params));
+          break;
+        case "endSpan":
+          data = await this.executeWithRetry(() => this.endSpan(params));
+          break;
+        case "addEvent":
+          data = await this.executeWithRetry(() => this.addEvent(params));
+          break;
+        case "recordMetric":
+          data = await this.executeWithRetry(() => this.recordMetric(params));
+          break;
+        case "getSpan":
+          data = await this.executeWithRetry(() => this.getSpan(params));
+          break;
+        case "getMetrics":
+          data = await this.executeWithRetry(() => this.getAllMetrics());
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return {
+        success: true,
+        data,
+        metadata: this.createMetadata(action, Date.now() - startTime)
+      };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Actions
+  // ---------------------------------------------------------------------------
+  async startSpan(params) {
+    const name = params.name;
+    const attributes = params.attributes ?? {};
+    const spanId = randomHexId(8);
+    const traceId = params.traceId ?? randomHexId(16);
+    const span = {
+      spanId,
+      traceId,
+      name,
+      startTime: Date.now(),
+      attributes,
+      events: []
+    };
+    this.spans.set(spanId, span);
+    this.logger.debug("Span started", { spanId, traceId, name });
+    return { spanId, traceId };
+  }
+  async endSpan(params) {
+    const spanId = params.spanId;
+    const status = params.status;
+    const span = this.spans.get(spanId);
+    if (!span) {
+      this.logger.warn("endSpan called for unknown span", { spanId });
+      return { ended: false };
+    }
+    span.endTime = Date.now();
+    if (status) {
+      span.status = status;
+    }
+    this.logger.debug("Span ended", { spanId, status, duration: span.endTime - span.startTime });
+    return { ended: true };
+  }
+  async addEvent(params) {
+    const spanId = params.spanId;
+    const name = params.name;
+    const attributes = params.attributes;
+    const span = this.spans.get(spanId);
+    if (!span) {
+      this.logger.warn("addEvent called for unknown span", { spanId });
+      return { added: false };
+    }
+    span.events.push({
+      name,
+      timestamp: Date.now(),
+      attributes
+    });
+    this.logger.debug("Event added to span", { spanId, eventName: name });
+    return { added: true };
+  }
+  async recordMetric(params) {
+    const name = params.name;
+    const value = params.value;
+    const type = params.type ?? "counter";
+    const labels = params.labels ?? {};
+    const existing = this.metrics.get(name);
+    if (existing) {
+      switch (type) {
+        case "counter":
+          existing.value += value;
+          break;
+        case "gauge":
+          existing.value = value;
+          break;
+        case "histogram":
+          existing.values.push(value);
+          break;
+      }
+      existing.labels = labels;
+    } else {
+      this.metrics.set(name, {
+        name,
+        type,
+        value: type === "histogram" ? 0 : value,
+        values: type === "histogram" ? [value] : [],
+        labels
+      });
+    }
+    this.logger.debug("Metric recorded", { name, value, type });
+    return { recorded: true };
+  }
+  async getSpan(params) {
+    const spanId = params.spanId;
+    const span = this.spans.get(spanId);
+    return span ?? null;
+  }
+  async getAllMetrics() {
+    const result = {};
+    for (const [key, metric] of this.metrics) {
+      result[key] = metric;
+    }
+    return result;
+  }
+};
+registerIntegration("otel", OtelIntegration);
+
+// src/integrations/oauth/index.ts
+var PROVIDER_AUTH_URLS = {
+  google: "https://accounts.google.com/o/oauth2/v2/auth",
+  github: "https://github.com/login/oauth/authorize",
+  auth0: "https://auth.example.com/authorize"
+};
+var OAuthIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    /** Maps state token -> provider for pending authorization flows */
+    this.states = /* @__PURE__ */ new Map();
+    /** Maps access token -> token set */
+    this.tokens = /* @__PURE__ */ new Map();
+    /** Maps refresh token -> access token for refresh lookups */
+    this.refreshIndex = /* @__PURE__ */ new Map();
+    /** Maps access token -> mock user session */
+    this.sessions = /* @__PURE__ */ new Map();
+    this.logger.info("OAuth integration initialized (mock backend)");
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    try {
+      let data;
+      switch (action) {
+        case "authorize":
+          data = await this.executeWithRetry(() => this.authorize(params));
+          break;
+        case "token":
+          data = await this.executeWithRetry(() => this.token(params));
+          break;
+        case "refresh":
+          data = await this.executeWithRetry(() => this.refresh(params));
+          break;
+        case "revoke":
+          data = await this.executeWithRetry(() => this.revoke(params));
+          break;
+        case "userinfo":
+          data = await this.executeWithRetry(() => this.userinfo(params));
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return {
+        success: true,
+        data,
+        metadata: this.createMetadata(action, Date.now() - startTime)
+      };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  /** Generate a random hex token of the given byte length. */
+  generateToken(bytes = 32) {
+    const chars = "abcdef0123456789";
+    let result = "";
+    for (let i = 0; i < bytes * 2; i++) {
+      result += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return result;
+  }
+  /** Generate a mock user profile from a provider and access token. */
+  generateMockUser(provider, sub) {
+    return {
+      sub,
+      email: `user-${sub.slice(0, 8)}@${provider}.example.com`,
+      name: `Mock User (${provider})`,
+      picture: `https://${provider}.example.com/avatar/${sub.slice(0, 8)}.png`
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Actions
+  // ---------------------------------------------------------------------------
+  async authorize(params) {
+    const provider = params.provider;
+    const scopes = params.scopes;
+    const redirectUri = params.redirectUri;
+    this.logger.debug("OAuth AUTHORIZE", { provider, scopes, redirectUri });
+    const state = this.generateToken(16);
+    this.states.set(state, provider);
+    const baseUrl = PROVIDER_AUTH_URLS[provider];
+    const queryParams = new URLSearchParams({
+      response_type: "code",
+      scope: scopes.join(" "),
+      redirect_uri: redirectUri,
+      state,
+      client_id: this.config.env.CLIENT_ID ?? "mock-client-id"
+    });
+    const authUrl = `${baseUrl}?${queryParams.toString()}`;
+    return { authUrl, state };
+  }
+  async token(params) {
+    const code = params.code;
+    const state = params.state;
+    this.logger.debug("OAuth TOKEN", { code, state });
+    const provider = this.states.get(state);
+    if (!provider) {
+      throw new Error(
+        `Invalid or expired state token: ${state}`
+      );
+    }
+    this.states.delete(state);
+    const accessToken = this.generateToken(32);
+    const refreshToken = this.generateToken(32);
+    const expiresIn = 3600;
+    const tokenSet = {
+      accessToken,
+      refreshToken,
+      expiresAt: Date.now() + expiresIn * 1e3
+    };
+    this.tokens.set(accessToken, tokenSet);
+    this.refreshIndex.set(refreshToken, accessToken);
+    const sub = this.generateToken(8);
+    this.sessions.set(accessToken, this.generateMockUser(provider, sub));
+    return { accessToken, refreshToken, expiresIn, tokenType: "bearer" };
+  }
+  async refresh(params) {
+    const refreshToken = params.refreshToken;
+    this.logger.debug("OAuth REFRESH", { refreshToken: refreshToken.slice(0, 8) + "..." });
+    const oldAccessToken = this.refreshIndex.get(refreshToken);
+    if (!oldAccessToken) {
+      throw new Error("Invalid refresh token");
+    }
+    const userInfo = this.sessions.get(oldAccessToken);
+    this.tokens.delete(oldAccessToken);
+    this.sessions.delete(oldAccessToken);
+    const newAccessToken = this.generateToken(32);
+    const expiresIn = 3600;
+    const tokenSet = {
+      accessToken: newAccessToken,
+      refreshToken,
+      expiresAt: Date.now() + expiresIn * 1e3
+    };
+    this.tokens.set(newAccessToken, tokenSet);
+    this.refreshIndex.set(refreshToken, newAccessToken);
+    if (userInfo) {
+      this.sessions.set(newAccessToken, userInfo);
+    }
+    return { accessToken: newAccessToken, expiresIn };
+  }
+  async revoke(params) {
+    const token = params.token;
+    this.logger.debug("OAuth REVOKE", { token: token.slice(0, 8) + "..." });
+    const tokenSet = this.tokens.get(token);
+    if (tokenSet) {
+      this.refreshIndex.delete(tokenSet.refreshToken);
+      this.tokens.delete(token);
+      this.sessions.delete(token);
+      return { revoked: true };
+    }
+    const accessToken = this.refreshIndex.get(token);
+    if (accessToken) {
+      this.tokens.delete(accessToken);
+      this.sessions.delete(accessToken);
+      this.refreshIndex.delete(token);
+      return { revoked: true };
+    }
+    return { revoked: false };
+  }
+  async userinfo(params) {
+    const accessToken = params.accessToken;
+    this.logger.debug("OAuth USERINFO", { accessToken: accessToken.slice(0, 8) + "..." });
+    const tokenSet = this.tokens.get(accessToken);
+    if (!tokenSet) {
+      throw new Error("Invalid access token");
+    }
+    if (Date.now() > tokenSet.expiresAt) {
+      this.tokens.delete(accessToken);
+      this.sessions.delete(accessToken);
+      throw new Error("Access token expired");
+    }
+    const userInfo = this.sessions.get(accessToken);
+    if (!userInfo) {
+      throw new Error("No session found for access token");
+    }
+    return userInfo;
+  }
+};
+registerIntegration("oauth", OAuthIntegration);
+
+// src/integrations/storage/index.ts
+var StorageIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    this.objects = /* @__PURE__ */ new Map();
+    const storageUrl = config.env.STORAGE_URL;
+    if (storageUrl) {
+      this.logger.warn(
+        "STORAGE_URL is configured but real storage client is not yet implemented. Falling back to in-memory store.",
+        { storageUrl }
+      );
+    }
+    this.logger.info("Storage integration initialized (in-memory backend)");
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    try {
+      let data;
+      switch (action) {
+        case "upload":
+          data = await this.executeWithRetry(() => this.upload(params));
+          break;
+        case "download":
+          data = await this.executeWithRetry(() => this.download(params));
+          break;
+        case "list":
+          data = await this.executeWithRetry(() => this.list(params));
+          break;
+        case "delete":
+          data = await this.executeWithRetry(() => this.deleteObject(params));
+          break;
+        case "getSignedUrl":
+          data = await this.executeWithRetry(() => this.getSignedUrl(params));
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return {
+        success: true,
+        data,
+        metadata: this.createMetadata(action, Date.now() - startTime)
+      };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  /** Build a composite key from bucket and object key. */
+  compositeKey(bucket, key) {
+    return `${bucket}/${key}`;
+  }
+  /** Generate a deterministic etag from content. */
+  generateEtag(content) {
+    const raw = typeof content === "string" ? content : JSON.stringify(content);
+    let hash = 0;
+    for (let i = 0; i < raw.length; i++) {
+      const ch = raw.charCodeAt(i);
+      hash = (hash << 5) - hash + ch | 0;
+    }
+    return `"${Math.abs(hash).toString(16).padStart(8, "0")}"`;
+  }
+  /** Compute the byte size of content. */
+  computeSize(content) {
+    if (typeof content === "string") {
+      return new TextEncoder().encode(content).byteLength;
+    }
+    return JSON.stringify(content).length;
+  }
+  // ---------------------------------------------------------------------------
+  // Actions
+  // ---------------------------------------------------------------------------
+  async upload(params) {
+    const bucket = params.bucket;
+    const key = params.key;
+    const content = params.content;
+    const contentType = params.contentType ?? "application/octet-stream";
+    const metadata = params.metadata ?? {};
+    this.logger.debug("Storage UPLOAD", { bucket, key, contentType });
+    const size = this.computeSize(content);
+    const etag = this.generateEtag(content);
+    const obj = {
+      content,
+      contentType,
+      size,
+      metadata,
+      lastModified: Date.now(),
+      etag
+    };
+    this.objects.set(this.compositeKey(bucket, key), obj);
+    return { key, bucket, size, etag };
+  }
+  async download(params) {
+    const bucket = params.bucket;
+    const key = params.key;
+    this.logger.debug("Storage DOWNLOAD", { bucket, key });
+    const obj = this.objects.get(this.compositeKey(bucket, key));
+    if (!obj) {
+      throw new Error(`Object not found: ${bucket}/${key}`);
+    }
+    return {
+      content: obj.content,
+      contentType: obj.contentType,
+      size: obj.size,
+      metadata: obj.metadata
+    };
+  }
+  async list(params) {
+    const bucket = params.bucket;
+    const prefix = params.prefix ?? "";
+    const maxKeys = params.maxKeys ?? 1e3;
+    this.logger.debug("Storage LIST", { bucket, prefix, maxKeys });
+    const bucketPrefix = `${bucket}/`;
+    const fullPrefix = `${bucket}/${prefix}`;
+    const results = [];
+    for (const [compositeKey, obj] of this.objects) {
+      if (!compositeKey.startsWith(fullPrefix)) continue;
+      const objectKey = compositeKey.slice(bucketPrefix.length);
+      results.push({
+        key: objectKey,
+        size: obj.size,
+        lastModified: obj.lastModified
+      });
+    }
+    results.sort((a, b) => a.key.localeCompare(b.key));
+    const truncated = results.length > maxKeys;
+    return {
+      keys: results.slice(0, maxKeys),
+      truncated
+    };
+  }
+  async deleteObject(params) {
+    const bucket = params.bucket;
+    const key = params.key;
+    this.logger.debug("Storage DELETE", { bucket, key });
+    const existed = this.objects.has(this.compositeKey(bucket, key));
+    this.objects.delete(this.compositeKey(bucket, key));
+    return { deleted: existed };
+  }
+  async getSignedUrl(params) {
+    const bucket = params.bucket;
+    const key = params.key;
+    const expiresIn = params.expiresIn ?? 3600;
+    const operation = params.operation ?? "get";
+    this.logger.debug("Storage GET_SIGNED_URL", { bucket, key, expiresIn, operation });
+    const expiresAt = Date.now() + expiresIn * 1e3;
+    const token = Math.random().toString(36).slice(2, 18);
+    const url = `https://storage.mock.local/${bucket}/${key}?X-Amz-Algorithm=MOCK-HMAC-SHA256&X-Amz-Expires=${expiresIn}&X-Amz-SignedHeaders=host&X-Amz-Signature=${token}&operation=${operation}`;
+    return { url, expiresAt };
+  }
+};
+registerIntegration("storage", StorageIntegration);
+
+// src/integrations/docker/index.ts
+var DockerIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    this.containers = /* @__PURE__ */ new Map();
+    this.images = /* @__PURE__ */ new Map();
+    const dockerHost = config.env.DOCKER_HOST;
+    if (dockerHost) {
+      this.logger.warn(
+        "DOCKER_HOST is configured but real Docker client is not yet implemented. Falling back to in-memory simulation.",
+        { dockerHost }
+      );
+    }
+    this.logger.info("Docker integration initialized (in-memory simulation)");
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    try {
+      let data;
+      switch (action) {
+        case "build":
+          data = await this.executeWithRetry(() => this.build(params));
+          break;
+        case "run":
+          data = await this.executeWithRetry(() => this.run(params));
+          break;
+        case "stop":
+          data = await this.executeWithRetry(() => this.stop(params));
+          break;
+        case "remove":
+          data = await this.executeWithRetry(() => this.removeContainer(params));
+          break;
+        case "logs":
+          data = await this.executeWithRetry(() => this.logs(params));
+          break;
+        case "status":
+          data = await this.executeWithRetry(() => this.status(params));
+          break;
+        case "list":
+          data = await this.executeWithRetry(() => this.list(params));
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return {
+        success: true,
+        data,
+        metadata: this.createMetadata(action, Date.now() - startTime)
+      };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  /** Generate a random hex container/image ID. */
+  generateId() {
+    const segments = [];
+    for (let i = 0; i < 16; i++) {
+      segments.push(Math.floor(Math.random() * 256).toString(16).padStart(2, "0"));
+    }
+    return segments.join("");
+  }
+  /** Find a container by ID (prefix match supported). */
+  findContainer(containerId) {
+    const exact = this.containers.get(containerId);
+    if (exact) return exact;
+    for (const [id, container] of this.containers) {
+      if (id.startsWith(containerId)) {
+        return container;
+      }
+    }
+    return void 0;
+  }
+  /** Generate realistic log lines for a container. */
+  generateLogLines(container, count) {
+    const lines = [...container.logs];
+    const baseTime = container.startedAt ?? container.createdAt;
+    while (lines.length < count) {
+      const ts = new Date(baseTime + lines.length * 1e3).toISOString();
+      lines.push(`${ts} [info] Container ${container.name} \u2014 heartbeat #${lines.length + 1}`);
+    }
+    return lines;
+  }
+  // ---------------------------------------------------------------------------
+  // Actions
+  // ---------------------------------------------------------------------------
+  async build(params) {
+    const dockerfile = params.dockerfile ?? "Dockerfile";
+    const tag = params.tag;
+    const context = params.context ?? ".";
+    const buildArgs = params.buildArgs ?? {};
+    this.logger.debug("Docker BUILD", { dockerfile, tag, context, buildArgs });
+    const imageId = `sha256:${this.generateId()}`;
+    const size = 15e7 + Math.floor(Math.random() * 35e7);
+    const buildTime = 2e3 + Math.floor(Math.random() * 8e3);
+    const image = {
+      id: imageId,
+      tag,
+      dockerfile,
+      size,
+      createdAt: Date.now()
+    };
+    this.images.set(tag, image);
+    return { imageId, tag, size, buildTime };
+  }
+  async run(params) {
+    const image = params.image;
+    const name = params.name ?? `container-${this.generateId().slice(0, 12)}`;
+    const rawPorts = params.ports ?? [];
+    const env = params.env ?? {};
+    const rawVolumes = params.volumes ?? [];
+    const command = params.command ?? "";
+    this.logger.debug("Docker RUN", { image, name, ports: rawPorts, env, volumes: rawVolumes, command });
+    const containerId = this.generateId();
+    const ports = rawPorts.map((p) => ({
+      host: p.host,
+      container: p.container,
+      protocol: p.protocol ?? "tcp"
+    }));
+    const volumes = rawVolumes.map((v) => ({
+      host: v.host,
+      container: v.container
+    }));
+    const container = {
+      id: containerId,
+      name,
+      image,
+      status: "running",
+      ports,
+      env,
+      volumes,
+      command,
+      labels: {},
+      createdAt: Date.now(),
+      startedAt: Date.now(),
+      stoppedAt: null,
+      logs: [
+        `${(/* @__PURE__ */ new Date()).toISOString()} [info] Starting container ${name} from image ${image}`,
+        `${(/* @__PURE__ */ new Date()).toISOString()} [info] Container ${name} is now running`
+      ]
+    };
+    this.containers.set(containerId, container);
+    return {
+      containerId,
+      name,
+      status: container.status,
+      ports
+    };
+  }
+  async stop(params) {
+    const containerId = params.containerId;
+    this.logger.debug("Docker STOP", { containerId });
+    const container = this.findContainer(containerId);
+    if (!container) {
+      throw new Error(`Container not found: ${containerId}`);
+    }
+    if (container.status !== "running" && container.status !== "paused") {
+      throw new Error(`Container ${containerId} is not running (current status: ${container.status})`);
+    }
+    container.status = "exited";
+    container.stoppedAt = Date.now();
+    container.logs.push(
+      `${(/* @__PURE__ */ new Date()).toISOString()} [info] Container ${container.name} stopped`
+    );
+    return {
+      containerId: container.id,
+      status: container.status,
+      stoppedAt: container.stoppedAt
+    };
+  }
+  async removeContainer(params) {
+    const containerId = params.containerId;
+    const force = params.force ?? false;
+    this.logger.debug("Docker REMOVE", { containerId, force });
+    const container = this.findContainer(containerId);
+    if (!container) {
+      throw new Error(`Container not found: ${containerId}`);
+    }
+    if (container.status === "running" && !force) {
+      throw new Error(
+        `Container ${containerId} is running. Stop it first or use force=true.`
+      );
+    }
+    this.containers.delete(container.id);
+    return { containerId: container.id, removed: true };
+  }
+  async logs(params) {
+    const containerId = params.containerId;
+    const tail = params.tail ?? 100;
+    const since = params.since ?? void 0;
+    this.logger.debug("Docker LOGS", { containerId, tail, since });
+    const container = this.findContainer(containerId);
+    if (!container) {
+      throw new Error(`Container not found: ${containerId}`);
+    }
+    let logLines = this.generateLogLines(container, tail);
+    if (since) {
+      const sinceMs = new Date(since).getTime();
+      logLines = logLines.filter((line) => {
+        const timestampMatch = /^\d{4}-\d{2}-\d{2}T[\d:.]+Z/.exec(line);
+        if (!timestampMatch) return true;
+        return new Date(timestampMatch[0]).getTime() >= sinceMs;
+      });
+    }
+    const tailedLines = logLines.slice(-tail);
+    return {
+      containerId: container.id,
+      logs: tailedLines,
+      lineCount: tailedLines.length
+    };
+  }
+  async status(params) {
+    const containerId = params.containerId;
+    this.logger.debug("Docker STATUS", { containerId });
+    const container = this.findContainer(containerId);
+    if (!container) {
+      throw new Error(`Container not found: ${containerId}`);
+    }
+    return {
+      containerId: container.id,
+      name: container.name,
+      image: container.image,
+      status: container.status,
+      ports: container.ports,
+      createdAt: container.createdAt,
+      startedAt: container.startedAt,
+      stoppedAt: container.stoppedAt
+    };
+  }
+  async list(params) {
+    const showAll = params.all ?? false;
+    const filterByLabel = params.filterByLabel ?? void 0;
+    this.logger.debug("Docker LIST", { all: showAll, filterByLabel });
+    let entries = Array.from(this.containers.values());
+    if (!showAll) {
+      entries = entries.filter((c) => c.status === "running");
+    }
+    if (filterByLabel) {
+      const [labelKey, labelValue] = filterByLabel.split("=");
+      entries = entries.filter((c) => {
+        if (labelValue !== void 0) {
+          return c.labels[labelKey] === labelValue;
+        }
+        return labelKey in c.labels;
+      });
+    }
+    entries.sort((a, b) => b.createdAt - a.createdAt);
+    const containers = entries.map((c) => ({
+      id: c.id,
+      name: c.name,
+      image: c.image,
+      status: c.status,
+      ports: c.ports,
+      createdAt: c.createdAt
+    }));
+    return { containers, total: containers.length };
+  }
+};
+registerIntegration("docker", DockerIntegration);
+
+export { BaseIntegration, CLIIntegration, ConsoleLogger, DeepAgentIntegration, DockerIntegration, EmailIntegration, GitHubIntegration, IntegrationFactory, LLMIntegration, OAuthIntegration, OtelIntegration, QueueIntegration, RedisIntegration, StorageIntegration, StripeIntegration, TwilioIntegration, YouTubeIntegration, getIntegration, getRegisteredIntegrations, isKnownIntegration, registerIntegration, validateParams, withRetry };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map