heyhank 0.1.0 → 0.2.0

package/server/routes/content-routes.ts

@@ -0,0 +1,116 @@
+// ─── Content Engine Routes ──────────────────────────────────────────────────
+// REST API for the Content Engine / Ad Creator system.
+
+import type { Hono } from "hono";
+
+export function registerContentRoutes(api: Hono): void {
+  /** Analyze a website — extract brand identity, products, colors, tone */
+  api.post("/content/analyze", async (c) => {
+    try {
+      const body = await c.req.json();
+      const url = (body.url || "").trim();
+      if (!url) return c.json({ error: "url is required" }, 400);
+
+      const { analyzeWebsite } = await import("../content-intelligence/content-engine.js");
+      const intelligence = await analyzeWebsite(url);
+      return c.json(intelligence);
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "Analysis failed" }, 500);
+    }
+  });
+
+  /** Create a content strategy based on website analysis */
+  api.post("/content/strategy", async (c) => {
+    try {
+      const body = await c.req.json();
+      const url = (body.url || "").trim();
+      if (!url) return c.json({ error: "url is required" }, 400);
+
+      const platformsStr = (body.platforms as string | undefined) || "instagram,linkedin,facebook";
+      const platforms = Array.isArray(platformsStr)
+        ? platformsStr
+        : platformsStr.split(",").map((p: string) => p.trim()).filter(Boolean);
+
+      const { analyzeWebsite, createContentStrategy } = await import("../content-intelligence/content-engine.js");
+      const intelligence = await analyzeWebsite(url);
+      const strategy = createContentStrategy(intelligence, platforms);
+      return c.json(strategy);
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "Strategy creation failed" }, 500);
+    }
+  });
+
+  /** Generate platform-optimized content pieces */
+  api.post("/content/generate", async (c) => {
+    try {
+      const body = await c.req.json();
+      const url = (body.url || "").trim();
+      const platform = (body.platform || "").trim();
+      if (!url) return c.json({ error: "url is required" }, 400);
+      if (!platform) return c.json({ error: "platform is required" }, 400);
+
+      const count = body.count || 5;
+      const journeyStage = body.journeyStage || undefined;
+      const styleProfileHandle =
+        typeof body.styleProfileHandle === "string" && body.styleProfileHandle.trim()
+          ? body.styleProfileHandle.trim()
+          : undefined;
+
+      const { analyzeWebsite, createContentStrategy, generateSmartContent } = await import("../content-intelligence/content-engine.js");
+      const intelligence = await analyzeWebsite(url);
+      const strategy = createContentStrategy(intelligence, [platform]);
+      const pieces = await generateSmartContent({
+        intelligence,
+        strategy,
+        platform,
+        journeyStage,
+        count,
+        styleProfileHandle,
+      });
+      return c.json({ pieces, count: pieces.length });
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "Content generation failed" }, 500);
+    }
+  });
+
+  /** Generate ad creatives */
+  api.post("/content/ads", async (c) => {
+    try {
+      const body = await c.req.json();
+      const url = (body.url || "").trim();
+      const platform = (body.platform || "").trim();
+      if (!url) return c.json({ error: "url is required" }, 400);
+      if (!platform) return c.json({ error: "platform is required" }, 400);
+
+      const count = body.count || 3;
+
+      const { analyzeWebsite, generateAdCreatives } = await import("../content-intelligence/content-engine.js");
+      const intelligence = await analyzeWebsite(url);
+      const ads = await generateAdCreatives({ intelligence, platform, count });
+      return c.json({ ads, count: ads.length });
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "Ad generation failed" }, 500);
+    }
+  });
+
+  /** Generate a complete multi-week content plan */
+  api.post("/content/plan", async (c) => {
+    try {
+      const body = await c.req.json();
+      const url = (body.url || "").trim();
+      if (!url) return c.json({ error: "url is required" }, 400);
+
+      const platformsStr = (body.platforms as string | undefined) || "instagram,linkedin,facebook";
+      const platforms = Array.isArray(platformsStr)
+        ? platformsStr
+        : platformsStr.split(",").map((p: string) => p.trim()).filter(Boolean);
+      const weeks = body.weeks || 4;
+
+      const { generateContentPlan } = await import("../content-intelligence/content-engine.js");
+      const plan = await generateContentPlan({ url, platforms, weeks });
+      return c.json(plan);
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "Plan generation failed" }, 500);
+    }
+  });
+}

package/server/routes/email-routes.ts

@@ -0,0 +1,147 @@
+// ─── Email Routes ────────────────────────────────────────────────────────────
+// REST API for multi-account email management (IMAP/SMTP).
+
+import type { Hono } from "hono";
+import * as email from "../email-service.js";
+import type { EmailAccount } from "../email-service.js";
+
+/** Strip auth.pass from an account object before returning it to the client. */
+function sanitizeAccount(account: EmailAccount): Omit<EmailAccount, "auth"> & { auth: { user: string } } {
+  const { auth, ...rest } = account;
+  return { ...rest, auth: { user: auth.user } };
+}
+
+export function registerEmailRoutes(api: Hono): void {
+  // ─── Account Management ─────────────────────────────────────────────
+
+  api.get("/assistant/email/accounts", (c) => {
+    const accounts = email.loadAccounts().map(sanitizeAccount);
+    return c.json({ accounts });
+  });
+
+  api.post("/assistant/email/accounts", async (c) => {
+    const body = await c.req.json<{
+      name: string;
+      email: string;
+      imap: { host: string; port: number; secure: boolean };
+      smtp: { host: string; port: number; secure: boolean };
+      auth: { user: string; pass: string };
+    }>();
+    if (!body.name || !body.email || !body.imap || !body.smtp || !body.auth) {
+      return c.json({ error: "name, email, imap, smtp, and auth are required" }, 400);
+    }
+    const account = email.addAccount(body);
+    return c.json(sanitizeAccount(account));
+  });
+
+  api.delete("/assistant/email/accounts/:id", (c) => {
+    const ok = email.removeAccount(c.req.param("id"));
+    return c.json({ ok });
+  });
+
+  api.post("/assistant/email/accounts/:id/test", async (c) => {
+    const account = email.getAccount(c.req.param("id"));
+    if (!account) return c.json({ error: "account not found" }, 404);
+    try {
+      await email.listEmails(account, { limit: 1 });
+      return c.json({ ok: true, message: "IMAP connection successful" });
+    } catch (err: any) {
+      return c.json({ ok: false, error: err?.message || "connection failed" }, 500);
+    }
+  });
+
+  // ─── Unread Summary ─────────────────────────────────────────────────
+
+  api.get("/assistant/email/unread", async (c) => {
+    try {
+      const summary = await email.getUnreadSummary();
+      return c.json({ summary });
+    } catch (err: any) {
+      return c.json({ error: err?.message || "failed to get unread summary" }, 500);
+    }
+  });
+
+  // ─── Per-Account Email Operations ───────────────────────────────────
+
+  api.get("/assistant/email/:accountId/messages", async (c) => {
+    const account = email.getAccount(c.req.param("accountId"));
+    if (!account) return c.json({ error: "account not found" }, 404);
+
+    const limit = c.req.query("limit") ? Number(c.req.query("limit")) : undefined;
+    const unseen = c.req.query("unseen") === "true" ? true : undefined;
+    const folder = c.req.query("folder") || undefined;
+
+    try {
+      const messages = await email.listEmails(account, { limit, unseen, folder });
+      return c.json({ messages });
+    } catch (err: any) {
+      return c.json({ error: err?.message || "failed to list emails" }, 500);
+    }
+  });
+
+  api.get("/assistant/email/:accountId/messages/:uid", async (c) => {
+    const account = email.getAccount(c.req.param("accountId"));
+    if (!account) return c.json({ error: "account not found" }, 404);
+
+    const uid = Number(c.req.param("uid"));
+    const folder = c.req.query("folder") || undefined;
+
+    try {
+      const message = await email.readEmail(account, uid, folder);
+      if (!message) return c.json({ error: "message not found" }, 404);
+      return c.json({ message });
+    } catch (err: any) {
+      return c.json({ error: err?.message || "failed to read email" }, 500);
+    }
+  });
+
+  api.get("/assistant/email/:accountId/search", async (c) => {
+    const account = email.getAccount(c.req.param("accountId"));
+    if (!account) return c.json({ error: "account not found" }, 404);
+
+    const q = c.req.query("q");
+    if (!q) return c.json({ error: "q query parameter is required" }, 400);
+    const limit = c.req.query("limit") ? Number(c.req.query("limit")) : undefined;
+
+    try {
+      const messages = await email.searchEmails(account, q, limit);
+      return c.json({ messages });
+    } catch (err: any) {
+      return c.json({ error: err?.message || "search failed" }, 500);
+    }
+  });
+
+  api.post("/assistant/email/:accountId/send", async (c) => {
+    const account = email.getAccount(c.req.param("accountId"));
+    if (!account) return c.json({ error: "account not found" }, 404);
+
+    const body = await c.req.json<{ to: string; subject: string; body: string }>();
+    if (!body.to || !body.subject || !body.body) {
+      return c.json({ error: "to, subject, and body are required" }, 400);
+    }
+
+    try {
+      const result = await email.sendEmail(account, body.to, body.subject, body.body);
+      return c.json(result);
+    } catch (err: any) {
+      return c.json({ error: err?.message || "failed to send email" }, 500);
+    }
+  });
+
+  api.post("/assistant/email/:accountId/reply", async (c) => {
+    const account = email.getAccount(c.req.param("accountId"));
+    if (!account) return c.json({ error: "account not found" }, 404);
+
+    const body = await c.req.json<{ uid: number; body: string }>();
+    if (!body.uid || !body.body) {
+      return c.json({ error: "uid and body are required" }, 400);
+    }
+
+    try {
+      const result = await email.replyToEmail(account, body.uid, body.body);
+      return c.json(result);
+    } catch (err: any) {
+      return c.json({ error: err?.message || "failed to reply" }, 500);
+    }
+  });
+}

package/server/routes/env-routes.ts

@@ -65,7 +65,7 @@ export function registerEnvRoutes(
       return c.json({ error: "Base Dockerfile not found at " + dockerfilePath }, 404);
     }
     try {
-      const log = containerManager.buildImage(dockerfilePath, "the-companion:latest");
+      const log = containerManager.buildImage(dockerfilePath, "heyhank:latest");
       return c.json({ success: true, log });
     } catch (e: unknown) {
       return c.json({ success: false, error: e instanceof Error ? e.message : String(e) }, 500);
@@ -73,8 +73,8 @@ export function registerEnvRoutes(
   });
 
   api.get("/docker/base-image", (c) => {
-    const exists = containerManager.imageExists("the-companion:latest");
-    return c.json({ exists, image: "the-companion:latest" });
+    const exists = containerManager.imageExists("heyhank:latest");
+    return c.json({ exists, image: "heyhank:latest" });
   });
 
   api.get("/images/:tag/status", (c) => {

package/server/routes/fs-routes.ts

@@ -112,7 +112,7 @@ export function registerFsRoutes(api: Hono, opts?: { allowedBases?: string[] }):
     const cwd = process.cwd();
     // Only report cwd if the user launched heyhank from a real project directory
     // (not from the package root or the home directory itself)
-    const packageRoot = process.env.__HEYHANK_PACKAGE_ROOT || process.env.__COMPANION_PACKAGE_ROOT;
+    const packageRoot = process.env.__HEYHANK_PACKAGE_ROOT || process.env.__COMPANION_PACKAGE_ROOT /* legacy */;
     const isProjectDir =
       cwd !== home &&
       (!packageRoot || !cwd.startsWith(packageRoot));
@@ -243,14 +243,15 @@ export function registerFsRoutes(api: Hono, opts?: { allowedBases?: string[] }):
     const filePath = c.req.query("path");
     if (!filePath) return c.json({ error: "path required" }, 400);
     const base = c.req.query("base");
-    const absPath = resolve(filePath);
+    const absPath = guardPath(filePath, allowedBases());
+    if (!absPath) return c.json({ error: "Path outside allowed directories" }, 403);
     try {
       const repoRoot = execSync("git rev-parse --show-toplevel", {
         cwd: dirname(absPath),
         encoding: "utf-8",
         timeout: 5000,
       }).trim();
-      const relPath = execSync(`git -C "${repoRoot}" ls-files --full-name -- "${absPath}"`, {
+      const relPath = execSync(`git -C ${shellEscapeArg(repoRoot)} ls-files --full-name -- ${shellEscapeArg(absPath)}`, {
         encoding: "utf-8",
         timeout: 5000,
       }).trim() || absPath;
@@ -261,7 +262,7 @@ export function registerFsRoutes(api: Hono, opts?: { allowedBases?: string[] }):
         const diffBases = resolveBranchDiffBases(repoRoot);
         for (const b of diffBases) {
           try {
-            diff = execCaptureStdout(`git diff ${b} -- "${relPath}"`, {
+            diff = execCaptureStdout(`git diff ${shellEscapeArg(b)} -- ${shellEscapeArg(relPath)}`, {
               cwd: repoRoot,
               encoding: "utf-8",
               timeout: 5000,
@@ -273,7 +274,7 @@ export function registerFsRoutes(api: Hono, opts?: { allowedBases?: string[] }):
         }
       } else {
         try {
-          diff = execCaptureStdout(`git diff HEAD -- "${relPath}"`, {
+          diff = execCaptureStdout(`git diff HEAD -- ${shellEscapeArg(relPath)}`, {
             cwd: repoRoot,
             encoding: "utf-8",
             timeout: 5000,
@@ -284,13 +285,13 @@ export function registerFsRoutes(api: Hono, opts?: { allowedBases?: string[] }):
       }
 
       if (!diff.trim()) {
-        const untracked = execSync(`git ls-files --others --exclude-standard -- "${relPath}"`, {
+        const untracked = execSync(`git ls-files --others --exclude-standard -- ${shellEscapeArg(relPath)}`, {
           cwd: repoRoot,
           encoding: "utf-8",
           timeout: 5000,
         }).trim();
         if (untracked) {
-          diff = execCaptureStdout(`git diff --no-index -- /dev/null "${absPath}"`, {
+          diff = execCaptureStdout(`git diff --no-index -- /dev/null ${shellEscapeArg(absPath)}`, {
             cwd: repoRoot,
             encoding: "utf-8",
             timeout: 5000,
@@ -312,7 +313,8 @@ export function registerFsRoutes(api: Hono, opts?: { allowedBases?: string[] }):
     const cwd = c.req.query("cwd");
     if (!cwd) return c.json({ error: "cwd required" }, 400);
     const base = c.req.query("base"); // "last-commit" | "default-branch" | undefined
-    const resolvedCwd = resolve(cwd);
+    const resolvedCwd = guardPath(cwd, allowedBases());
+    if (!resolvedCwd) return c.json({ error: "Path outside allowed directories" }, 403);
     try {
       const repoRoot = execSync("git rev-parse --show-toplevel", {
         cwd: resolvedCwd,
@@ -604,7 +606,8 @@ export function registerFsRoutes(api: Hono, opts?: { allowedBases?: string[] }):
     if (base !== "CLAUDE.md") {
       return c.json({ error: "Can only write CLAUDE.md files" }, 400);
     }
-    const absPath = resolve(filePath);
+    const absPath = guardPath(filePath, allowedBases());
+    if (!absPath) return c.json({ error: "Path outside allowed directories" }, 403);
     if (!absPath.endsWith("/CLAUDE.md") && !absPath.endsWith("/.claude/CLAUDE.md")) {
       return c.json({ error: "Invalid CLAUDE.md path" }, 400);
     }