heyhank 0.1.0

package/server/shared-context.ts

@@ -0,0 +1,157 @@
+// ─── Shared Context System ───────────────────────────────────────────────────
+// Cross-agent knowledge sharing via markdown files
+// Ported from AgentManager/src/storage.ts (context portion)
+
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  statSync,
+} from "node:fs";
+import { join } from "node:path";
+import { HEYHANK_HOME } from "./paths.js";
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const SHARED_CONTEXT_DIR = join(HEYHANK_HOME, "shared-context");
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface ContextFile {
+  filename: string;
+  content: string;
+  updatedAt: string;
+  sizeBytes: number;
+}
+
+// ─── Functions ───────────────────────────────────────────────────────────────
+
+function ensureDir(): void {
+  mkdirSync(SHARED_CONTEXT_DIR, { recursive: true });
+}
+
+/** List all shared context files. */
+export function listContextFiles(): ContextFile[] {
+  ensureDir();
+  try {
+    const files = readdirSync(SHARED_CONTEXT_DIR).filter((f) =>
+      f.endsWith(".md"),
+    );
+    return files.map((filename) => {
+      const filePath = join(SHARED_CONTEXT_DIR, filename);
+      const content = readFileSync(filePath, "utf-8");
+      const stats = statSync(filePath);
+      return {
+        filename,
+        content,
+        updatedAt: stats.mtime.toISOString(),
+        sizeBytes: stats.size,
+      };
+    });
+  } catch (err) {
+    console.error("[shared-context] Failed to list:", err);
+    return [];
+  }
+}
+
+/** Read a specific context file. */
+export function getContextFile(filename: string): ContextFile | null {
+  ensureDir();
+  const filePath = join(SHARED_CONTEXT_DIR, filename);
+  if (!existsSync(filePath)) return null;
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const stats = statSync(filePath);
+    return {
+      filename,
+      content,
+      updatedAt: stats.mtime.toISOString(),
+      sizeBytes: stats.size,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** Write or update a context file. */
+export function writeContextFile(filename: string, content: string): ContextFile {
+  ensureDir();
+  if (!filename.endsWith(".md")) {
+    filename = filename + ".md";
+  }
+  // Sanitize filename
+  filename = filename.replace(/[^a-zA-Z0-9._-]/g, "-");
+  const filePath = join(SHARED_CONTEXT_DIR, filename);
+  writeFileSync(filePath, content, "utf-8");
+  const stats = statSync(filePath);
+  return {
+    filename,
+    content,
+    updatedAt: stats.mtime.toISOString(),
+    sizeBytes: stats.size,
+  };
+}
+
+/** Delete a context file. */
+export function deleteContextFile(filename: string): boolean {
+  const filePath = join(SHARED_CONTEXT_DIR, filename);
+  if (!existsSync(filePath)) return false;
+  try {
+    unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Create default context files if none exist. */
+export function ensureDefaultContextFiles(): void {
+  ensureDir();
+  const files = readdirSync(SHARED_CONTEXT_DIR).filter((f) =>
+    f.endsWith(".md"),
+  );
+  if (files.length > 0) return;
+
+  writeContextFile(
+    "platform-info.md",
+    `# Agent Platform Info
+
+## Server
+- HeyHank Platform
+- 8 Cores, 31 GB RAM
+- Node 22, Bun, PM2, Nginx, Redis, PostgreSQL
+
+## Agents
+- Coding Agent: Full-stack development
+- Monitoring Agent: Server health checks
+- Marketing Agent: SEO, Ads, Analytics
+- Content Agent: Social media, images, video
+- Personal Agent: Email, calendar, reminders
+- Agent Max 2.0: Autonomous meta-agent
+
+## Key Directories
+- Platform: /opt/agentplatform/
+- Agent Configs: ~/.heyhank/agents/
+- Shared Context: ~/.heyhank/shared-context/
+`,
+  );
+
+  writeContextFile(
+    "active-projects.md",
+    `# Active Projects
+
+Track active projects here. Each agent can read and update this file.
+
+## Projects
+<!-- Add projects as they come up -->
+`,
+  );
+
+  console.log("[shared-context] Created default context files");
+}
+
+// Initialize on import
+ensureDefaultContextFiles();

package/server/socialmedia/adapter.ts

@@ -0,0 +1,15 @@
+// Social Media Adapter interface
+import type { SocialProfile, CreatePostInput, PostAnalytics, AccountAnalytics, SocialComment, SocialPlatform } from "./types.js";
+
+export interface SocialMediaAdapter {
+  testConnection(): Promise<{ ok: boolean; error?: string; data?: unknown }>;
+  getProfiles(): Promise<SocialProfile[]>;
+  supportedPlatforms(): SocialPlatform[];
+  createPost(input: CreatePostInput): Promise<{ id: string | null; status: string; backendData?: unknown }>;
+  listPosts(opts?: { limit?: number }): Promise<Array<{ id: string; text: string; status: string; platforms: string[]; createdAt?: string | null; scheduledAt?: string | null }>>;
+  deletePost(postId: string): Promise<boolean>;
+  getAnalytics(postId: string): Promise<PostAnalytics>;
+  getAccountAnalytics(profileId: string): Promise<AccountAnalytics>;
+  getComments(postId: string): Promise<SocialComment[]>;
+  replyToComment(postId: string, commentId: string | null, text: string): Promise<{ ok: boolean; error?: string }>;
+}

package/server/socialmedia/adapters/ayrshare-adapter.ts

@@ -0,0 +1,169 @@
+// ─── Ayrshare Adapter ────────────────────────────────────────────────────────
+// REST client for Ayrshare social media API.
+
+import type { SocialMediaAdapter } from "../adapter.js";
+import type { SocialProfile, CreatePostInput, PostAnalytics, AccountAnalytics, SocialComment, SocialPlatform } from "../types.js";
+
+const BASE_URL = "https://app.ayrshare.com/api";
+
+export class AyrshareAdapter implements SocialMediaAdapter {
+  private apiKey: string;
+
+  constructor(config: { apiKey: string }) {
+    this.apiKey = config.apiKey;
+  }
+
+  private headers(): Record<string, string> {
+    return {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.apiKey}`,
+    };
+  }
+
+  async testConnection(): Promise<{ ok: boolean; error?: string; data?: unknown }> {
+    try {
+      const res = await fetch(`${BASE_URL}/user`, { headers: this.headers() });
+      if (!res.ok) {
+        return { ok: false, error: `Ayrshare returned ${res.status}: ${res.statusText}` };
+      }
+      const data = await res.json();
+      return { ok: true, data };
+    } catch (err: any) {
+      return { ok: false, error: err?.message ?? "Connection failed" };
+    }
+  }
+
+  async getProfiles(): Promise<SocialProfile[]> {
+    try {
+      const res = await fetch(`${BASE_URL}/user`, { headers: this.headers() });
+      if (!res.ok) return [];
+      const data = await res.json();
+      const accounts: string[] = data.activeSocialAccounts ?? [];
+      return accounts.map((platform) => ({
+        id: platform,
+        platform: platform as SocialPlatform,
+        name: data.displayNames?.[platform] ?? platform,
+        picture: null,
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  supportedPlatforms(): SocialPlatform[] {
+    return ["twitter", "instagram", "linkedin", "facebook", "tiktok", "threads"];
+  }
+
+  async createPost(input: CreatePostInput): Promise<{ id: string | null; status: string; backendData?: unknown }> {
+    try {
+      const body: any = {
+        post: input.text,
+        platforms: input.platforms,
+      };
+      if (input.scheduledAt) {
+        body.scheduleDate = input.scheduledAt;
+      }
+      if (input.mediaUrls?.length) {
+        body.mediaUrls = input.mediaUrls;
+      }
+
+      const res = await fetch(`${BASE_URL}/post`, {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify(body),
+      });
+      const data = await res.json();
+      if (!res.ok || data.status === "error") {
+        return { id: null, status: "failed", backendData: data };
+      }
+      return {
+        id: data.id ?? null,
+        status: data.scheduleDate ? "scheduled" : "published",
+        backendData: data,
+      };
+    } catch (err: any) {
+      return { id: null, status: "failed", backendData: { error: err?.message } };
+    }
+  }
+
+  async listPosts(opts?: { limit?: number }): Promise<Array<{ id: string; text: string; status: string; platforms: string[]; createdAt?: string | null; scheduledAt?: string | null }>> {
+    try {
+      const res = await fetch(`${BASE_URL}/history`, { headers: this.headers() });
+      if (!res.ok) return [];
+      const data = await res.json();
+      const posts = Array.isArray(data) ? data : [];
+      return posts.slice(0, opts?.limit ?? 50).map((p: any) => ({
+        id: p.id ?? "",
+        text: p.post ?? p.text ?? "",
+        status: p.status ?? "unknown",
+        platforms: p.platforms ?? [],
+        createdAt: p.created ?? p.createdAt ?? null,
+        scheduledAt: p.scheduleDate ?? null,
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  async deletePost(postId: string): Promise<boolean> {
+    try {
+      const res = await fetch(`${BASE_URL}/post`, {
+        method: "DELETE",
+        headers: this.headers(),
+        body: JSON.stringify({ id: postId }),
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async getAnalytics(postId: string): Promise<PostAnalytics> {
+    try {
+      const res = await fetch(`${BASE_URL}/analytics/post`, {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify({ id: postId }),
+      });
+      if (!res.ok) return { impressions: 0, likes: 0, shares: 0, comments: 0 };
+      const data = await res.json();
+      return {
+        impressions: data.impressions ?? 0,
+        likes: data.likes ?? data.engagements?.likes ?? 0,
+        shares: data.shares ?? data.engagements?.shares ?? 0,
+        comments: data.comments ?? data.engagements?.comments ?? 0,
+      };
+    } catch {
+      return { impressions: 0, likes: 0, shares: 0, comments: 0 };
+    }
+  }
+
+  async getAccountAnalytics(profileId: string): Promise<AccountAnalytics> {
+    try {
+      const res = await fetch(`${BASE_URL}/analytics/social`, {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify({ platforms: [profileId] }),
+      });
+      if (!res.ok) return { followers: 0, following: 0, posts: 0 };
+      const data = await res.json();
+      const analytics = data?.[profileId] ?? data;
+      return {
+        followers: analytics.followers ?? 0,
+        following: analytics.following ?? 0,
+        posts: analytics.posts ?? 0,
+      };
+    } catch {
+      return { followers: 0, following: 0, posts: 0 };
+    }
+  }
+
+  async getComments(_postId: string): Promise<SocialComment[]> {
+    // Ayrshare comments not yet implemented
+    return [];
+  }
+
+  async replyToComment(_postId: string, _commentId: string | null, _text: string): Promise<{ ok: boolean; error?: string }> {
+    return { ok: false, error: "Ayrshare comment replies not yet implemented" };
+  }
+}

package/server/socialmedia/adapters/buffer-adapter.ts

@@ -0,0 +1,299 @@
+// ─── Buffer Adapter ──────────────────────────────────────────────────────────
+// GraphQL client for Buffer's new API (https://developers.buffer.com).
+// Auth: Bearer token via Authorization header.
+// Endpoint: POST https://api.buffer.com (GraphQL).
+
+import type { SocialMediaAdapter } from "../adapter.js";
+import type { SocialProfile, CreatePostInput, PostAnalytics, AccountAnalytics, SocialComment, SocialPlatform } from "../types.js";
+
+const API_URL = "https://api.buffer.com";
+
+const SERVICE_TO_PLATFORM: Record<string, SocialPlatform> = {
+  twitter: "twitter",
+  instagram: "instagram",
+  linkedin: "linkedin",
+  facebook: "facebook",
+  tiktok: "tiktok",
+  threads: "threads",
+};
+
+export class BufferAdapter implements SocialMediaAdapter {
+  private token: string;
+  private orgId: string | null = null;
+
+  constructor(config: { apiKey: string }) {
+    this.token = config.apiKey;
+  }
+
+  private async gql<T = any>(query: string, variables?: Record<string, unknown>): Promise<T> {
+    const body: Record<string, unknown> = { query };
+    if (variables) body.variables = variables;
+
+    const res = await fetch(API_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.token}`,
+      },
+      body: JSON.stringify(body),
+    });
+
+    const json = await res.json() as any;
+
+    if (json.errors?.length) {
+      const msg = json.errors.map((e: any) => e.message).join("; ");
+      throw new Error(msg);
+    }
+
+    return json.data as T;
+  }
+
+  /** Fetch and cache the first organization ID (needed for most queries). */
+  private async getOrgId(): Promise<string> {
+    if (this.orgId) return this.orgId;
+
+    const data = await this.gql<{ account: { organizations: Array<{ id: string; name: string }> } }>(`
+      query GetOrganizations {
+        account {
+          organizations {
+            id
+            name
+          }
+        }
+      }
+    `);
+
+    const orgs = data.account?.organizations ?? [];
+    if (orgs.length === 0) throw new Error("No organizations found in Buffer account");
+    this.orgId = orgs[0].id;
+    return this.orgId;
+  }
+
+  async testConnection(): Promise<{ ok: boolean; error?: string; data?: unknown }> {
+    try {
+      const data = await this.gql(`
+        query GetOrganizations {
+          account {
+            organizations {
+              id
+              name
+              ownerEmail
+            }
+          }
+        }
+      `);
+      return { ok: true, data };
+    } catch (err: any) {
+      return { ok: false, error: err?.message ?? "Connection failed" };
+    }
+  }
+
+  async getProfiles(): Promise<SocialProfile[]> {
+    try {
+      const orgId = await this.getOrgId();
+      const data = await this.gql<{ channels: Array<{ id: string; name: string; displayName: string; service: string; avatar: string | null }> }>(`
+        query GetChannels($orgId: String!) {
+          channels(input: { organizationId: $orgId }) {
+            id
+            name
+            displayName
+            service
+            avatar
+          }
+        }
+      `, { orgId });
+
+      return (data.channels ?? []).map((ch) => ({
+        id: ch.id,
+        platform: (SERVICE_TO_PLATFORM[ch.service] ?? ch.service) as SocialPlatform,
+        name: ch.displayName || ch.name || ch.service,
+        picture: ch.avatar ?? null,
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  supportedPlatforms(): SocialPlatform[] {
+    return ["twitter", "instagram", "linkedin", "facebook", "tiktok", "threads"];
+  }
+
+  async createPost(input: CreatePostInput): Promise<{ id: string | null; status: string; backendData?: unknown }> {
+    try {
+      // Resolve channel IDs for selected platforms
+      const profiles = await this.getProfiles();
+      const channels = profiles.filter((p) => input.platforms.includes(p.platform));
+
+      if (channels.length === 0) {
+        return { id: null, status: "failed", backendData: { error: "No connected channels match the selected platforms" } };
+      }
+
+      // Create a post for each matching channel
+      const results: Array<{ id: string | null; error?: string }> = [];
+
+      for (const channel of channels) {
+        const isScheduled = !!input.scheduledAt;
+        const mode = isScheduled ? "customScheduled" : "addToQueue";
+
+        // Build the input inline to support assets and dueAt conditionally
+        let inputFields = `text: ${JSON.stringify(input.text)}, channelId: "${channel.id}", schedulingType: automatic, mode: ${mode}`;
+
+        if (isScheduled) {
+          inputFields += `, dueAt: "${input.scheduledAt}"`;
+        }
+
+        if (input.mediaUrls?.length) {
+          const images = input.mediaUrls.map((url) => `{ url: ${JSON.stringify(url)} }`).join(", ");
+          inputFields += `, assets: { images: [${images}] }`;
+        }
+
+        const query = `
+          mutation CreatePost {
+            createPost(input: { ${inputFields} }) {
+              ... on PostActionSuccess {
+                post {
+                  id
+                  text
+                  dueAt
+                }
+              }
+              ... on MutationError {
+                message
+              }
+            }
+          }
+        `;
+
+        const data = await this.gql<{ createPost: { post?: { id: string }; message?: string } }>(query);
+
+        if (data.createPost?.post?.id) {
+          results.push({ id: data.createPost.post.id });
+        } else {
+          results.push({ id: null, error: data.createPost?.message ?? "Unknown error" });
+        }
+      }
+
+      const firstSuccess = results.find((r) => r.id);
+      if (firstSuccess) {
+        return {
+          id: firstSuccess.id,
+          status: input.scheduledAt ? "scheduled" : "published",
+          backendData: results,
+        };
+      }
+
+      return { id: null, status: "failed", backendData: results };
+    } catch (err: any) {
+      return { id: null, status: "failed", backendData: { error: err?.message } };
+    }
+  }
+
+  async listPosts(opts?: { limit?: number }): Promise<Array<{ id: string; text: string; status: string; platforms: string[]; createdAt?: string | null; scheduledAt?: string | null }>> {
+    try {
+      const orgId = await this.getOrgId();
+      const limit = opts?.limit ?? 50;
+
+      // Fetch sent and scheduled posts
+      const [sentData, scheduledData] = await Promise.all([
+        this.gql<{ posts: { edges: Array<{ node: { id: string; text: string; createdAt: string; dueAt?: string; channelId: string; status: string } }> } }>(`
+          query GetSentPosts($orgId: String!, $first: Int) {
+            posts(first: $first, input: {
+              organizationId: $orgId,
+              sort: [{ field: dueAt, direction: desc }],
+              filter: { status: sent }
+            }) {
+              edges {
+                node { id text createdAt dueAt channelId status }
+              }
+            }
+          }
+        `, { orgId, first: limit }),
+        this.gql<{ posts: { edges: Array<{ node: { id: string; text: string; createdAt: string; dueAt?: string; channelId: string; status: string } }> } }>(`
+          query GetScheduledPosts($orgId: String!, $first: Int) {
+            posts(first: $first, input: {
+              organizationId: $orgId,
+              sort: [{ field: dueAt, direction: asc }],
+              filter: { status: scheduled }
+            }) {
+              edges {
+                node { id text createdAt dueAt channelId status }
+              }
+            }
+          }
+        `, { orgId, first: limit }),
+      ]);
+
+      const profiles = await this.getProfiles();
+      const channelToPlatform = new Map(profiles.map((p) => [p.id, p.platform]));
+
+      const posts: Array<{ id: string; text: string; status: string; platforms: string[]; createdAt?: string | null; scheduledAt?: string | null }> = [];
+
+      for (const edge of sentData.posts?.edges ?? []) {
+        const n = edge.node;
+        posts.push({
+          id: n.id,
+          text: n.text ?? "",
+          status: "published",
+          platforms: [channelToPlatform.get(n.channelId) ?? "unknown"],
+          createdAt: n.createdAt ?? null,
+          scheduledAt: null,
+        });
+      }
+
+      for (const edge of scheduledData.posts?.edges ?? []) {
+        const n = edge.node;
+        posts.push({
+          id: n.id,
+          text: n.text ?? "",
+          status: "scheduled",
+          platforms: [channelToPlatform.get(n.channelId) ?? "unknown"],
+          createdAt: n.createdAt ?? null,
+          scheduledAt: n.dueAt ?? null,
+        });
+      }
+
+      return posts.slice(0, limit);
+    } catch {
+      return [];
+    }
+  }
+
+  async deletePost(postId: string): Promise<boolean> {
+    try {
+      const data = await this.gql<{ deletePost: { post?: { id: string }; message?: string } }>(`
+        mutation DeletePost {
+          deletePost(input: { postId: "${postId}" }) {
+            ... on PostActionSuccess {
+              post { id }
+            }
+            ... on MutationError {
+              message
+            }
+          }
+        }
+      `);
+      return !!data.deletePost?.post?.id;
+    } catch {
+      return false;
+    }
+  }
+
+  async getAnalytics(_postId: string): Promise<PostAnalytics> {
+    // Buffer's new GraphQL API does not expose per-post analytics yet
+    return { impressions: 0, likes: 0, shares: 0, comments: 0 };
+  }
+
+  async getAccountAnalytics(profileId: string): Promise<AccountAnalytics> {
+    // Buffer's new GraphQL API does not expose account analytics yet
+    return { followers: 0, following: 0, posts: 0 };
+  }
+
+  async getComments(_postId: string): Promise<SocialComment[]> {
+    // Buffer API does not expose comment threads
+    return [];
+  }
+
+  async replyToComment(_postId: string, _commentId: string | null, _text: string): Promise<{ ok: boolean; error?: string }> {
+    return { ok: false, error: "Buffer does not support comment management via API" };
+  }
+}