heyhank 0.1.0 → 0.3.0

package/server/routes/sandbox-routes.ts

@@ -81,7 +81,7 @@ export function registerSandboxRoutes(
 
     if (!containerManager.checkDocker()) return c.json({ error: "Docker is not available" }, 503);
 
-    const effectiveImage = "the-companion:latest";
+    const effectiveImage = "heyhank:latest";
     if (!imagePullManager.isReady(effectiveImage)) {
       return c.json({ error: `Docker image ${effectiveImage} is not available. Pull it first.` }, 503);
     }

package/server/routes/settings-routes.ts

@@ -87,6 +87,12 @@ export function registerSettingsRoutes(api: Hono): void {
       publicUrl: settings.publicUrl,
       updateChannel: settings.updateChannel,
       dockerAutoUpdate: settings.dockerAutoUpdate,
+      hankChatProvider: settings.hankChatProvider,
+      hankChatModel: settings.hankChatModel,
+      hankChatAvatarEnabled: settings.hankChatAvatarEnabled,
+      hankChatAvatarUrl: settings.hankChatAvatarUrl,
+      obsidianVaultPath: settings.obsidianVaultPath,
+      openrouterApiKeyConfigured: !!process.env.OPENROUTER_API_KEY?.trim(),
     });
   });
 
@@ -140,6 +146,15 @@ export function registerSettingsRoutes(api: Hono): void {
     if (body.dockerAutoUpdate !== undefined && typeof body.dockerAutoUpdate !== "boolean") {
       return c.json({ error: "dockerAutoUpdate must be a boolean" }, 400);
     }
+    if (body.obsidianVaultPath !== undefined && typeof body.obsidianVaultPath !== "string") {
+      return c.json({ error: "obsidianVaultPath must be a string" }, 400);
+    }
+    if (body.hankChatAvatarEnabled !== undefined && typeof body.hankChatAvatarEnabled !== "boolean") {
+      return c.json({ error: "hankChatAvatarEnabled must be a boolean" }, 400);
+    }
+    if (body.hankChatAvatarUrl !== undefined && typeof body.hankChatAvatarUrl !== "string") {
+      return c.json({ error: "hankChatAvatarUrl must be a string" }, 400);
+    }
     const hasAnyField = body.anthropicApiKey !== undefined || body.anthropicModel !== undefined
       || body.claudeCodeOAuthToken !== undefined || body.openaiApiKey !== undefined
       || body.onboardingCompleted !== undefined
@@ -150,7 +165,12 @@ export function registerSettingsRoutes(api: Hono): void {
       || body.aiValidationAutoDeny !== undefined
       || body.publicUrl !== undefined
       || body.updateChannel !== undefined
-      || body.dockerAutoUpdate !== undefined;
+      || body.dockerAutoUpdate !== undefined
+      || body.hankChatProvider !== undefined
+      || body.hankChatModel !== undefined
+      || body.hankChatAvatarEnabled !== undefined
+      || body.hankChatAvatarUrl !== undefined
+      || body.obsidianVaultPath !== undefined;
     if (!hasAnyField) {
       return c.json({ error: "At least one settings field is required" }, 400);
     }
@@ -224,8 +244,32 @@ export function registerSettingsRoutes(api: Hono): void {
         typeof body.dockerAutoUpdate === "boolean"
           ? body.dockerAutoUpdate
           : undefined,
+      hankChatProvider:
+        typeof body.hankChatProvider === "string"
+          ? body.hankChatProvider.trim()
+          : undefined,
+      hankChatModel:
+        typeof body.hankChatModel === "string"
+          ? body.hankChatModel.trim()
+          : undefined,
+      hankChatAvatarEnabled:
+        typeof body.hankChatAvatarEnabled === "boolean"
+          ? body.hankChatAvatarEnabled
+          : undefined,
+      hankChatAvatarUrl:
+        typeof body.hankChatAvatarUrl === "string"
+          ? body.hankChatAvatarUrl.trim()
+          : undefined,
+      obsidianVaultPath:
+        typeof body.obsidianVaultPath === "string"
+          ? body.obsidianVaultPath.trim()
+          : undefined,
     });
 
+    if (body.obsidianVaultPath !== undefined) {
+      import("../memory-service.js").then(m => m.restartVaultSync()).catch(() => {});
+    }
+
     const claudeAuthAfter = detectClaudeAuthStatus();
     const codexAuthAfter = detectCodexAuthStatus();
     return c.json({
@@ -249,6 +293,12 @@ export function registerSettingsRoutes(api: Hono): void {
       publicUrl: settings.publicUrl,
       updateChannel: settings.updateChannel,
       dockerAutoUpdate: settings.dockerAutoUpdate,
+      hankChatProvider: settings.hankChatProvider,
+      hankChatModel: settings.hankChatModel,
+      hankChatAvatarEnabled: settings.hankChatAvatarEnabled,
+      hankChatAvatarUrl: settings.hankChatAvatarUrl,
+      obsidianVaultPath: settings.obsidianVaultPath,
+      openrouterApiKeyConfigured: !!process.env.OPENROUTER_API_KEY?.trim(),
     });
   });
 

package/server/routes/socialmedia-routes.ts

@@ -4,6 +4,8 @@
 import type { Hono } from "hono";
 import * as store from "../socialmedia/store.js";
 import * as manager from "../socialmedia/manager.js";
+import * as browser from "../socialview/browser-manager.js";
+import type { SocialPlatform as ViewPlatform } from "../socialview/types.js";
 
 export function registerSocialMediaRoutes(api: Hono): void {
   // ─── Settings ───────────────────────────────────────────────────────
@@ -56,6 +58,26 @@ export function registerSocialMediaRoutes(api: Hono): void {
     }
   });
 
+  /**
+   * Browser-backed status for the platforms we post via Playwright
+   * (X / Twitter and TikTok). Other platforms continue to use the
+   * primary backend (Postiz).
+   */
+  api.get("/socialmedia/browser-status", (c) => {
+    const platforms: ViewPlatform[] = ["twitter", "tiktok"];
+    const statuses = platforms.map((p) => {
+      const s = browser.getStatus(p);
+      return {
+        platform: p,
+        running: s.running,
+        loggedIn: s.loggedIn,
+        currentUrl: s.currentUrl,
+        hasProfile: browser.hasProfile(p),
+      };
+    });
+    return c.json({ platforms: statuses });
+  });
+
   /** Get connected profiles */
   api.get("/socialmedia/profiles", async (c) => {
     try {
@@ -74,12 +96,23 @@ export function registerSocialMediaRoutes(api: Hono): void {
       const body = await c.req.json();
       const text = (body.text || "").trim();
       if (!text) return c.json({ error: "text required" }, 400);
+      // Accept both mediaUrls (array) and imageUrl (string) for compatibility
+      let mediaUrls: string[] = body.mediaUrls || [];
+      if (mediaUrls.length === 0 && body.imageUrl) {
+        mediaUrls = [body.imageUrl];
+      }
       const result = await manager.createPost({
         text,
         platforms: body.platforms || [],
         scheduledAt: body.scheduledAt || null,
-        mediaUrls: body.mediaUrls || [],
+        mediaUrls,
+        isDraft: body.isDraft ?? false,
+        title: body.title,
+        firstComment: body.firstComment,
+        videoUrl: body.videoUrl,
+        thumbnailUrl: body.thumbnailUrl,
       });
+      if (body.createdBy && result) (result as any).createdBy = body.createdBy;
       return c.json(result, 201);
     } catch (e) {
       return c.json({ error: e instanceof Error ? e.message : "failed" }, 500);
@@ -115,7 +148,22 @@ export function registerSocialMediaRoutes(api: Hono): void {
       if (!post) return c.json({ error: "post not found" }, 404);
       if (body.text !== undefined) post.text = body.text;
       if (body.scheduledAt !== undefined) post.scheduledAt = body.scheduledAt;
-      if (body.platforms !== undefined) post.platforms = body.platforms;
+      if (body.platforms !== undefined) {
+        // Coerce object-array shapes (`[{id, name}]`) back to string[].
+        if (Array.isArray(body.platforms)) {
+          post.platforms = body.platforms
+            .map((p: unknown) => {
+              if (typeof p === "string") return p;
+              if (p && typeof p === "object") {
+                const o = p as { name?: unknown; platform?: unknown };
+                if (typeof o.name === "string") return o.name;
+                if (typeof o.platform === "string") return o.platform;
+              }
+              return null;
+            })
+            .filter((s: unknown): s is string => typeof s === "string" && s.length > 0);
+        }
+      }
       if (body.scheduledAt && post.status === "published") post.status = "scheduled";
       store.savePost(post);
       return c.json(post);
@@ -135,12 +183,42 @@ export function registerSocialMediaRoutes(api: Hono): void {
     }
   });
 
+  /** Move a published/scheduled/failed post back to draft (deletes from backend) */
+  api.post("/socialmedia/posts/:id/move-to-draft", async (c) => {
+    try {
+      const post = await manager.moveToDraft(c.req.param("id"));
+      return c.json(post);
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : "Failed" }, 400);
+    }
+  });
+
   /** Delete post */
   api.delete("/socialmedia/posts/:id", async (c) => {
     const ok = await manager.deletePost(c.req.param("id"));
     return c.json({ ok }, ok ? 200 : 404);
   });
 
+  /** Archive post (hide from default queue view) */
+  api.post("/socialmedia/posts/:id/archive", async (c) => {
+    try {
+      const post = await manager.setArchived(c.req.param("id"), true);
+      return c.json(post);
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "failed" }, 400);
+    }
+  });
+
+  /** Unarchive post (restore previous status) */
+  api.post("/socialmedia/posts/:id/unarchive", async (c) => {
+    try {
+      const post = await manager.setArchived(c.req.param("id"), false);
+      return c.json(post);
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "failed" }, 400);
+    }
+  });
+
   /** Get post analytics */
   api.get("/socialmedia/posts/:id/analytics", async (c) => {
     try {
@@ -194,6 +272,78 @@ export function registerSocialMediaRoutes(api: Hono): void {
     }
   });
 
+  // ─── Hashtag Pools ─────────────────────────────────────────────────
+
+  /** List all hashtag pools */
+  api.get("/socialmedia/hashtag-pools", (c) => {
+    try {
+      const pools = store.listHashtagPools();
+      return c.json({ pools });
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "failed" }, 500);
+    }
+  });
+
+  /** Get single hashtag pool */
+  api.get("/socialmedia/hashtag-pools/:id", (c) => {
+    const pool = store.getHashtagPool(c.req.param("id"));
+    if (!pool) return c.json({ error: "pool not found" }, 404);
+    return c.json(pool);
+  });
+
+  /** Create or update hashtag pool */
+  api.post("/socialmedia/hashtag-pools", async (c) => {
+    try {
+      const body = await c.req.json();
+      if (!body.name) return c.json({ error: "name required" }, 400);
+      const { randomUUID } = await import("node:crypto");
+      const now = new Date().toISOString();
+      const pool = {
+        id: body.id || randomUUID(),
+        name: body.name,
+        industry: body.industry || "",
+        language: body.language || "de",
+        popular: body.popular || [],
+        medium: body.medium || [],
+        niche: body.niche || [],
+        branded: body.branded || [],
+        blocked: body.blocked || [],
+        createdAt: body.createdAt || now,
+        updatedAt: now,
+      };
+      store.saveHashtagPool(pool);
+      return c.json(pool, 201);
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "bad request" }, 400);
+    }
+  });
+
+  /** Update hashtag pool */
+  api.put("/socialmedia/hashtag-pools/:id", async (c) => {
+    try {
+      const id = c.req.param("id");
+      const existing = store.getHashtagPool(id);
+      if (!existing) return c.json({ error: "pool not found" }, 404);
+      const body = await c.req.json();
+      const pool = {
+        ...existing,
+        ...body,
+        id, // don't allow id change
+        updatedAt: new Date().toISOString(),
+      };
+      store.saveHashtagPool(pool);
+      return c.json(pool);
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "bad request" }, 400);
+    }
+  });
+
+  /** Delete hashtag pool */
+  api.delete("/socialmedia/hashtag-pools/:id", (c) => {
+    const ok = store.deleteHashtagPool(c.req.param("id"));
+    return c.json({ ok }, ok ? 200 : 404);
+  });
+
   // ─── Account Analytics ──────────────────────────────────────────────
 
   /** Get account analytics for a profile */

package/server/routes/system-routes.ts

@@ -133,8 +133,8 @@ export function registerSystemRoutes(
         if (getSettings().dockerAutoUpdate) {
           try {
             console.log("[update] Re-pulling Docker image (dockerAutoUpdate enabled)...");
-            imagePullManager.pull("the-companion:latest");
-            const ready = await imagePullManager.waitForReady("the-companion:latest", 120_000);
+            imagePullManager.pull("heyhank:latest");
+            const ready = await imagePullManager.waitForReady("heyhank:latest", 120_000);
             if (ready) {
               console.log("[update] Docker image re-pull complete.");
             } else {

package/server/routes/team-routes.ts

@@ -0,0 +1,71 @@
+import type { Hono } from "hono";
+import * as teamService from "../team-service.js";
+
+export function registerTeamRoutes(api: Hono): void {
+  api.get("/teams", (c) => {
+    return c.json(teamService.listTeams());
+  });
+
+  api.get("/teams/:id", (c) => {
+    const team = teamService.getTeam(c.req.param("id"));
+    if (!team) return c.json({ error: "Team not found" }, 404);
+    return c.json(team);
+  });
+
+  api.get("/teams/:id/status", (c) => {
+    const status = teamService.getTeamStatus(c.req.param("id"));
+    if (!status) return c.json({ error: "Team not found" }, 404);
+    return c.json(status);
+  });
+
+  api.post("/teams", async (c) => {
+    const body = await c.req.json();
+    const team = teamService.createTeam({
+      goal: body.goal,
+      repoRoot: body.repoRoot || body.cwd,
+      baseBranch: body.baseBranch,
+      suggestedAgents: body.suggestedAgents,
+    });
+    return c.json(team, 201);
+  });
+
+  api.put("/teams/:id", async (c) => {
+    const body = await c.req.json();
+    const team = teamService.updateTeamState(c.req.param("id"), body.state, body);
+    if (!team) return c.json({ error: "Team not found" }, 404);
+    return c.json(team);
+  });
+
+  api.put("/teams/:id/tasks/:taskId", async (c) => {
+    const body = await c.req.json();
+    const team = teamService.updateTask(c.req.param("id"), c.req.param("taskId"), body);
+    if (!team) return c.json({ error: "Team or task not found" }, 404);
+    return c.json(team);
+  });
+
+  api.post("/teams/:id/complete", async (c) => {
+    const body = await c.req.json();
+    const team = teamService.updateTeamState(c.req.param("id"), "completed", {
+      result: body.result,
+      completedAt: Date.now(),
+    });
+    if (!team) return c.json({ error: "Team not found" }, 404);
+    return c.json(team);
+  });
+
+  api.post("/teams/:id/fail", async (c) => {
+    const body = await c.req.json();
+    const team = teamService.updateTeamState(c.req.param("id"), "failed", {
+      error: body.error,
+      completedAt: Date.now(),
+    });
+    if (!team) return c.json({ error: "Team not found" }, 404);
+    return c.json(team);
+  });
+
+  api.delete("/teams/:id", (c) => {
+    const success = teamService.deleteTeam(c.req.param("id"));
+    if (!success) return c.json({ error: "Team not found" }, 404);
+    return c.json({ ok: true });
+  });
+}

package/server/routes/telephony-routes.ts

@@ -5,7 +5,33 @@ import type { Hono } from "hono";
 import { callManager } from "../telephony/call-manager.js";
 import * as store from "../telephony/telephony-store.js";
 import type { CallConfig, SipTrunkConfig, TelephonyContact } from "../telephony/call-types.js";
+import { eslCommand, eslStatus } from "../telephony/esl-client.js";
+import { syncAndReload, checkGatewayStatus } from "../telephony/freeswitch-sync.js";
 import { randomUUID } from "node:crypto";
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { getPipelineSettingsFrom } from "../voice-pipeline/manager.js";
+import { preRenderAllGreetings, clearCache } from "../voice-pipeline/greeting-cache.js";
+
+/**
+ * Background-warm the greeting cache so the first call has 0ms TTS latency.
+ * Fire-and-forget — failures are logged but don't block the calling endpoint.
+ */
+function warmGreetingsAsync(opts: { clearFirst?: boolean } = {}): void {
+  setImmediate(async () => {
+    try {
+      const settings = store.getSettings();
+      const pipelineSettings = getPipelineSettingsFrom(settings);
+      if (!pipelineSettings.enabled || !pipelineSettings.preRenderGreetings) return;
+      if (opts.clearFirst) clearCache();
+      const stats = await preRenderAllGreetings(settings.contacts, pipelineSettings);
+      console.log(`[telephony] Greeting cache warmed: ${stats.rendered} rendered, ${stats.cached} cached, ${stats.errors} errors`);
+    } catch (e) {
+      console.error("[telephony] Greeting warm failed:", e);
+    }
+  });
+}
 
 export function registerTelephonyRoutes(api: Hono): void {
   // ─── Calls ───────────────────────────────────────────────────────────
@@ -72,6 +98,29 @@ export function registerTelephonyRoutes(api: Hono): void {
     }
   });
 
+  /** Serve call audio recording (WAV) */
+  api.get("/telephony/calls/:id/audio", (c) => {
+    const id = c.req.param("id");
+    // Validate UUID format to prevent path traversal
+    if (!/^[a-f0-9-]{36}$/.test(id)) {
+      return c.json({ error: "Invalid call ID" }, 400);
+    }
+    const wavPath = join(homedir(), ".heyhank", "telephony", "calls", `${id}.wav`);
+    if (!existsSync(wavPath)) {
+      return c.json({ error: "Audio recording not found" }, 404);
+    }
+    const file = Bun.file(wavPath);
+    const stat = statSync(wavPath);
+    return new Response(file, {
+      headers: {
+        "Content-Type": "audio/wav",
+        "Content-Length": String(stat.size),
+        "Content-Disposition": `inline; filename="${id}.wav"`,
+        "Cache-Control": "private, max-age=86400",
+      },
+    });
+  });
+
   /** Call history */
   api.get("/telephony/history", (c) => {
     const limit = parseInt(c.req.query("limit") || "50", 10);
@@ -122,6 +171,21 @@ export function registerTelephonyRoutes(api: Hono): void {
       }
 
       store.saveSettings(updated);
+
+      // If voice settings changed, invalidate greeting cache and re-warm
+      const oldVoice = getPipelineSettingsFrom(current).tts.voice;
+      const newVoice = getPipelineSettingsFrom(updated).tts.voice;
+      const voiceChanged = oldVoice !== newVoice;
+      warmGreetingsAsync({ clearFirst: voiceChanged });
+
+      // Re-sync inbound ESL listener with new settings (start if enabled, stop otherwise)
+      try {
+        callManager.stopInboundListener();
+        callManager.startInboundListener();
+      } catch (err) {
+        console.error("[telephony-routes] Failed to restart inbound listener:", err);
+      }
+
       return c.json({ success: true });
     } catch (err) {
       return c.json({ error: err instanceof Error ? err.message : "Failed to save settings" }, 500);
@@ -148,6 +212,9 @@ export function registerTelephonyRoutes(api: Hono): void {
       if (!settings.defaultTrunkId) settings.defaultTrunkId = trunk.id;
       store.saveSettings(settings);
 
+      // Auto-sync gateway to FreeSWITCH
+      syncAndReload().catch((err) => console.error("[telephony] Auto-sync failed:", err));
+
       return c.json(trunk);
     } catch (err) {
       return c.json({ error: err instanceof Error ? err.message : "Failed to add trunk" }, 500);
@@ -163,6 +230,10 @@ export function registerTelephonyRoutes(api: Hono): void {
       settings.defaultTrunkId = settings.trunks[0]?.id || null;
     }
     store.saveSettings(settings);
+
+    // Auto-sync after trunk removal
+    syncAndReload().catch((err) => console.error("[telephony] Auto-sync failed:", err));
+
     return c.json({ success: true });
   });
 
@@ -192,6 +263,7 @@ export function registerTelephonyRoutes(api: Hono): void {
         notes: body.notes?.trim() || undefined,
       };
       store.addContact(contact);
+      warmGreetingsAsync();
       return c.json(contact);
     } catch (err) {
       return c.json({ error: err instanceof Error ? err.message : "Failed to add contact" }, 500);
@@ -213,6 +285,8 @@ export function registerTelephonyRoutes(api: Hono): void {
       }
       const updated = store.updateContact(id, body);
       if (!updated) return c.json({ error: "Contact not found" }, 404);
+      // Re-render greeting if name/phone changed
+      if (body.name || body.phone) warmGreetingsAsync();
       return c.json(updated);
     } catch (err) {
       return c.json({ error: err instanceof Error ? err.message : "Failed to update contact" }, 500);
@@ -227,28 +301,13 @@ export function registerTelephonyRoutes(api: Hono): void {
     return c.json({ success: true });
   });
 
-  /** Test FreeSWITCH ESL connection */
+  /** Test FreeSWITCH ESL connection (TCP) */
   api.post("/telephony/test-connection", async (c) => {
     const settings = store.getSettings();
-    const { eslHost, eslPort, eslPassword } = settings.freeswitch;
 
     try {
-      const eslUrl = `http://${eslHost}:${eslPort}/api`;
-      const res = await fetch(eslUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "text/plain",
-          "Authorization": `Basic ${btoa(`freeswitch:${eslPassword}`)}`,
-        },
-        body: "status",
-        signal: AbortSignal.timeout(5000),
-      });
-
-      if (res.ok) {
-        const text = await res.text();
-        return c.json({ connected: true, status: text.trim().slice(0, 200) });
-      }
-      return c.json({ connected: false, error: `HTTP ${res.status}` });
+      const result = await eslStatus(settings.freeswitch);
+      return c.json({ connected: result.connected, status: result.status });
     } catch (err) {
       return c.json({
         connected: false,
@@ -256,4 +315,25 @@ export function registerTelephonyRoutes(api: Hono): void {
       });
     }
   });
+
+  /** Sync gateway configs to FreeSWITCH and reload */
+  api.post("/telephony/sync", async (c) => {
+    try {
+      await syncAndReload();
+      return c.json({ success: true, message: "Gateway configs synced and reloaded." });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : "Sync failed" }, 500);
+    }
+  });
+
+  /** Check gateway registration status */
+  api.get("/telephony/trunks/:id/status", async (c) => {
+    const id = c.req.param("id");
+    try {
+      const status = await checkGatewayStatus(id);
+      return c.json(status);
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : "Status check failed" }, 500);
+    }
+  });
 }

package/server/routes.ts

@@ -16,6 +16,7 @@ import * as sessionNames from "./session-names.js";
 import { containerManager } from "./container-manager.js";
 import { registerFsRoutes } from "./routes/fs-routes.js";
 import { registerSkillRoutes } from "./routes/skills-routes.js";
+import { registerMarketplaceRoutes } from "./routes/marketplace-routes.js";
 import { registerEnvRoutes } from "./routes/env-routes.js";
 import { registerSandboxRoutes } from "./routes/sandbox-routes.js";
 import { registerCronRoutes } from "./routes/cron-routes.js";
@@ -34,8 +35,17 @@ import { registerHubRoutes } from "./recording-hub/hub-routes.js";
 import { registerFederationRoutes } from "./routes/federation-routes.js";
 import { registerTelephonyRoutes } from "./routes/telephony-routes.js";
 import { registerSocialMediaRoutes } from "./routes/socialmedia-routes.js";
+import { registerSocialViewRoutes } from "./socialview/routes.js";
 import { registerAssistantRoutes } from "./routes/assistant-routes.js";
+import { registerEmailRoutes } from "./routes/email-routes.js";
 import { registerProviderRoutes } from "./routes/provider-routes.js";
+import { registerHankChatRoutes } from "./routes/hank-chat-routes.js";
+import { registerMemoryRoutes } from "./routes/memory-routes.js";
+import { registerTeamRoutes } from "./routes/team-routes.js";
+import { registerContentRoutes } from "./routes/content-routes.js";
+import { registerCeoDocumentRoutes } from "./routes/ceo-routes.js";
+import { registerCeoNewsTimeRoutes } from "./routes/ceo-news-time-routes.js";
+import { registerCeoFinanceKpiRoutes } from "./routes/ceo-finance-kpi-routes.js";
 import { nodeManager } from "./federation/node-manager.js";
 import { discoverClaudeSessions } from "./claude-session-discovery.js";
 import { getClaudeSessionHistoryPage } from "./claude-session-history.js";
@@ -135,17 +145,22 @@ export function createRoutes(
   // When behind a reverse proxy (Nginx), check X-Real-IP / X-Forwarded-For
   // headers first, since the TCP source will always be 127.0.0.1 from the proxy.
   function isLocalhostRequest(c: { env: unknown; req: { raw: Request; header: (name: string) => string | undefined } }): boolean {
-    // If a reverse proxy set X-Real-IP, use that (this is the real client IP)
+    // First determine the TCP peer address
+    const bunServer = c.env as { requestIP?: (req: Request) => { address: string } | null };
+    const ip = bunServer?.requestIP?.(c.req.raw);
+    const tcpAddr = ip?.address ?? "";
+    const tcpIsLocal = tcpAddr === "127.0.0.1" || tcpAddr === "::1" || tcpAddr === "::ffff:127.0.0.1";
+
+    // Only trust X-Real-IP when the TCP connection comes from localhost (i.e. a local reverse proxy)
     const realIp = c.req.header("x-real-ip");
-    if (realIp) {
+    if (realIp && tcpIsLocal) {
       const trimmed = realIp.trim();
       return trimmed === "127.0.0.1" || trimmed === "::1" || trimmed === "::ffff:127.0.0.1";
     }
-    // Fallback to TCP socket address (direct connections without proxy)
-    const bunServer = c.env as { requestIP?: (req: Request) => { address: string } | null };
-    const ip = bunServer?.requestIP?.(c.req.raw);
-    const addr = ip?.address ?? "";
-    return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
+
+    // If X-Real-IP is present but TCP is NOT localhost, ignore the header (spoofed)
+    // Fall back to TCP peer address
+    return tcpIsLocal;
   }
 
   api.get("/auth/auto", (c) => {
@@ -181,7 +196,9 @@ export function createRoutes(
     // send Authorization headers, but browsers do forward cookies automatically.
     const cookieToken = getCookie(c, "heyhank_auth") ?? null;
     if (!verifyToken(token) && !verifyToken(cookieToken)) {
-      return c.json({ error: "unauthorized" }, 401);
+      // Use 403 instead of 401 to prevent browsers from re-showing
+      // the Basic Auth dialog when Nginx basic auth is in front
+      return c.json({ error: "unauthorized" }, 403);
     }
     return next();
   });
@@ -601,7 +618,7 @@ export function createRoutes(
       return c.json({
         available: false,
         mode: "container" as const,
-        message: "Browser preview requires Xvfb and noVNC in the container image. Rebuild with the latest the-companion image.",
+        message: "Browser preview requires Xvfb and noVNC in the container image. Rebuild with the latest heyhank image.",
       });
     }
 
@@ -1324,6 +1341,7 @@ export function createRoutes(
   });
 
   registerSkillRoutes(api);
+  registerMarketplaceRoutes(api);
   registerCronRoutes(api, cronScheduler);
   registerAgentRoutes(api, agentExecutor);
   registerMetricsRoutes(api, { gaugeProvider: wsBridge });
@@ -1331,8 +1349,17 @@ export function createRoutes(
   registerFederationRoutes(api);
   registerTelephonyRoutes(api);
   registerSocialMediaRoutes(api);
+  registerSocialViewRoutes(api);
   registerAssistantRoutes(api);
+  registerEmailRoutes(api);
   registerProviderRoutes(api);
+  registerHankChatRoutes(api);
+  registerMemoryRoutes(api);
+  registerTeamRoutes(api);
+  registerContentRoutes(api);
+  registerCeoDocumentRoutes(api);
+  registerCeoNewsTimeRoutes(api);
+  registerCeoFinanceKpiRoutes(api);
 
   // ─── Gemini → Session bridge ───────────────────────────────────────
   // Allows Gemini voice chat tool calls to send messages to active sessions