heyhank 0.1.0

package/server/routes/socialmedia-routes.ts

@@ -0,0 +1,208 @@
+// ─── Social Media Routes ─────────────────────────────────────────────────────
+// REST API for social media posting, scheduling, analytics, and comments.
+
+import type { Hono } from "hono";
+import * as store from "../socialmedia/store.js";
+import * as manager from "../socialmedia/manager.js";
+
+export function registerSocialMediaRoutes(api: Hono): void {
+  // ─── Settings ───────────────────────────────────────────────────────
+
+  /** Get settings (API keys masked) */
+  api.get("/socialmedia/settings", (c) => {
+    try {
+      const settings = store.getSettings();
+      // Mask API keys
+      const masked = JSON.parse(JSON.stringify(settings));
+      for (const [, cfg] of Object.entries(masked.backends || {})) {
+        const conf = cfg as { apiKey?: string };
+        if (conf.apiKey) conf.apiKey = conf.apiKey.slice(0, 4) + "••••••••";
+      }
+      return c.json(masked);
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "failed" }, 500);
+    }
+  });
+
+  /** Save settings (restore masked keys from existing) */
+  api.put("/socialmedia/settings", async (c) => {
+    try {
+      const body = await c.req.json();
+      const existing = store.getSettings();
+      // Restore masked keys from existing settings
+      for (const [key, cfg] of Object.entries(body.backends || {})) {
+        const conf = cfg as { apiKey?: string };
+        if (conf.apiKey && conf.apiKey.includes("••••")) {
+          const existingKey = (existing.backends as Record<string, { apiKey?: string }>)?.[key]?.apiKey;
+          if (existingKey) conf.apiKey = existingKey;
+        }
+      }
+      store.saveSettings(body);
+      return c.json({ ok: true });
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "bad request" }, 400);
+    }
+  });
+
+  // ─── Connection ─────────────────────────────────────────────────────
+
+  /** Test backend connection */
+  api.post("/socialmedia/test-connection", async (c) => {
+    try {
+      const result = await manager.testConnection();
+      return c.json(result);
+    } catch (e) {
+      return c.json({ ok: false, error: e instanceof Error ? e.message : "failed" });
+    }
+  });
+
+  /** Get connected profiles */
+  api.get("/socialmedia/profiles", async (c) => {
+    try {
+      const profiles = await manager.getProfiles();
+      return c.json({ profiles });
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "failed" }, 500);
+    }
+  });
+
+  // ─── Posts ──────────────────────────────────────────────────────────
+
+  /** Create post */
+  api.post("/socialmedia/posts", async (c) => {
+    try {
+      const body = await c.req.json();
+      const text = (body.text || "").trim();
+      if (!text) return c.json({ error: "text required" }, 400);
+      const result = await manager.createPost({
+        text,
+        platforms: body.platforms || [],
+        scheduledAt: body.scheduledAt || null,
+        mediaUrls: body.mediaUrls || [],
+      });
+      return c.json(result, 201);
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "failed" }, 500);
+    }
+  });
+
+  /** List posts */
+  api.get("/socialmedia/posts", async (c) => {
+    const opts: { status?: string; platform?: string; limit?: number } = {};
+    const status = c.req.query("status");
+    const platform = c.req.query("platform");
+    const limit = c.req.query("limit");
+    if (status) opts.status = status;
+    if (platform) opts.platform = platform;
+    if (limit) opts.limit = parseInt(limit, 10);
+    const posts = await manager.listPosts(opts);
+    return c.json({ posts });
+  });
+
+  /** Get single post */
+  api.get("/socialmedia/posts/:id", async (c) => {
+    const post = await manager.getPost(c.req.param("id"));
+    if (!post) return c.json({ error: "post not found" }, 404);
+    return c.json(post);
+  });
+
+  /** Update/reschedule post */
+  api.patch("/socialmedia/posts/:id", async (c) => {
+    try {
+      const id = c.req.param("id");
+      const body = await c.req.json();
+      const post = store.getPost(id);
+      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.scheduledAt && post.status === "published") post.status = "scheduled";
+      store.savePost(post);
+      return c.json(post);
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "bad request" }, 400);
+    }
+  });
+
+  /** Publish draft */
+  api.post("/socialmedia/posts/:id/publish", async (c) => {
+    try {
+      const smManager = await import("../socialmedia/manager.js");
+      const post = await smManager.publishDraft(c.req.param("id"));
+      return c.json(post);
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : "Failed to publish" }, 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);
+  });
+
+  /** Get post analytics */
+  api.get("/socialmedia/posts/:id/analytics", async (c) => {
+    try {
+      const analytics = await manager.getPostAnalytics(c.req.param("id"));
+      return c.json(analytics);
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "failed" }, 500);
+    }
+  });
+
+  /** Get post comments */
+  api.get("/socialmedia/posts/:id/comments", async (c) => {
+    try {
+      const comments = await manager.getComments(c.req.param("id"));
+      return c.json({ comments });
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "failed" }, 500);
+    }
+  });
+
+  /** Reply to comment */
+  api.post("/socialmedia/posts/:id/comments", async (c) => {
+    try {
+      const body = await c.req.json();
+      const text = (body.text || "").trim();
+      if (!text) return c.json({ error: "text required" }, 400);
+      const result = await manager.replyToComment(c.req.param("id"), body.commentId || null, text);
+      return c.json(result);
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "failed" }, 500);
+    }
+  });
+
+  // ─── Calendar View ──────────────────────────────────────────────────
+
+  /** Get posts grouped by day for a month */
+  api.get("/socialmedia/calendar", (c) => {
+    try {
+      const month = c.req.query("month") || new Date().toISOString().slice(0, 7);
+      const allPosts = store.listLocalPosts({});
+      const grouped: Record<string, typeof allPosts> = {};
+      for (const p of allPosts) {
+        const dateStr = (p.scheduledAt || p.createdAt || "").slice(0, 10);
+        if (!dateStr.startsWith(month)) continue;
+        if (!grouped[dateStr]) grouped[dateStr] = [];
+        grouped[dateStr].push(p);
+      }
+      return c.json({ month, days: grouped });
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "failed" }, 500);
+    }
+  });
+
+  // ─── Account Analytics ──────────────────────────────────────────────
+
+  /** Get account analytics for a profile */
+  api.get("/socialmedia/analytics/:profileId", async (c) => {
+    try {
+      const analytics = await manager.getAccountAnalytics(c.req.param("profileId"));
+      return c.json(analytics);
+    } catch (e) {
+      return c.json({ error: e instanceof Error ? e.message : "failed" }, 500);
+    }
+  });
+}

package/server/routes/system-routes.ts

@@ -0,0 +1,228 @@
+import type { Hono } from "hono";
+import type { CliLauncher } from "../cli-launcher.js";
+import type { WsBridge } from "../ws-bridge.js";
+import type { TerminalManager } from "../terminal-manager.js";
+import { getUsageLimits } from "../usage-limits.js";
+import {
+  getUpdateState,
+  checkForUpdate,
+  isUpdateAvailable,
+  setUpdateInProgress,
+} from "../update-checker.js";
+import { refreshServiceDefinition } from "../service.js";
+import { getSettings } from "../settings-manager.js";
+import { imagePullManager } from "../image-pull-manager.js";
+
+export function registerSystemRoutes(
+  api: Hono,
+  deps: {
+    launcher: CliLauncher;
+    wsBridge: WsBridge;
+    terminalManager: TerminalManager;
+    updateCheckStaleMs: number;
+  },
+): void {
+  api.get("/usage-limits", async (c) => {
+    const limits = await getUsageLimits();
+    return c.json(limits);
+  });
+
+  api.get("/sessions/:id/usage-limits", async (c) => {
+    const sessionId = c.req.param("id");
+    const session = deps.wsBridge.getSession(sessionId);
+    const empty = { five_hour: null, seven_day: null, extra_usage: null };
+
+    if (session?.backendType === "codex") {
+      const rl = deps.wsBridge.getCodexRateLimits(sessionId);
+      if (!rl) return c.json(empty);
+      const toEpochMs = (value: number): number => (
+        value > 0 && value < 1_000_000_000_000 ? value * 1000 : value
+      );
+      const mapLimit = (l: { usedPercent: number; windowDurationMins: number; resetsAt: number } | null) => {
+        if (!l) return null;
+        const resetsAtMs = toEpochMs(l.resetsAt);
+        return {
+          utilization: l.usedPercent,
+          resets_at: resetsAtMs ? new Date(resetsAtMs).toISOString() : null,
+        };
+      };
+      return c.json({
+        five_hour: mapLimit(rl.primary),
+        seven_day: mapLimit(rl.secondary),
+        extra_usage: null,
+      });
+    }
+
+    const limits = await getUsageLimits();
+    return c.json(limits);
+  });
+
+  api.get("/update-check", async (c) => {
+    const initialState = getUpdateState();
+    const needsRefresh =
+      initialState.lastChecked === 0
+      || Date.now() - initialState.lastChecked > deps.updateCheckStaleMs;
+    if (needsRefresh) {
+      await checkForUpdate();
+    }
+
+    const state = getUpdateState();
+    return c.json({
+      currentVersion: state.currentVersion,
+      latestVersion: state.latestVersion,
+      updateAvailable: isUpdateAvailable(),
+      isServiceMode: state.isServiceMode,
+      updateInProgress: state.updateInProgress,
+      lastChecked: state.lastChecked,
+      channel: state.channel,
+    });
+  });
+
+  api.post("/update-check", async (c) => {
+    await checkForUpdate();
+    const state = getUpdateState();
+    return c.json({
+      currentVersion: state.currentVersion,
+      latestVersion: state.latestVersion,
+      updateAvailable: isUpdateAvailable(),
+      isServiceMode: state.isServiceMode,
+      updateInProgress: state.updateInProgress,
+      lastChecked: state.lastChecked,
+      channel: state.channel,
+    });
+  });
+
+  api.post("/update", async (c) => {
+    const state = getUpdateState();
+    if (!state.isServiceMode) {
+      return c.json(
+        { error: "Update & restart is only available in service mode" },
+        400,
+      );
+    }
+    if (!isUpdateAvailable()) {
+      return c.json({ error: "No update available" }, 400);
+    }
+    if (state.updateInProgress) {
+      return c.json({ error: "Update already in progress" }, 409);
+    }
+
+    setUpdateInProgress(true);
+
+    setTimeout(async () => {
+      try {
+        console.log(
+          `[update] Updating heyhank to ${state.latestVersion}...`,
+        );
+        const proc = Bun.spawn(
+          ["bun", "install", "-g", `heyhank@${state.latestVersion}`],
+          { stdout: "pipe", stderr: "pipe" },
+        );
+        const exitCode = await proc.exited;
+        if (exitCode !== 0) {
+          const stderr = await new Response(proc.stderr).text();
+          console.error(
+            `[update] bun install failed (code ${exitCode}):`,
+            stderr,
+          );
+          setUpdateInProgress(false);
+          return;
+        }
+
+        // Re-pull Docker image if auto-update is enabled
+        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);
+            if (ready) {
+              console.log("[update] Docker image re-pull complete.");
+            } else {
+              console.warn("[update] Docker image re-pull failed or timed out, continuing with restart.");
+            }
+          } catch (err) {
+            console.warn("[update] Docker image re-pull error, continuing:", err);
+          }
+        }
+
+        try {
+          refreshServiceDefinition();
+          console.log("[update] Service definition refreshed.");
+        } catch (err) {
+          console.warn("[update] Failed to refresh service definition:", err);
+        }
+
+        console.log("[update] Update successful, restarting service...");
+
+        const isLinux = process.platform === "linux";
+        const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
+        const restartCmd = isLinux
+          ? ["systemctl", "--user", "restart", "heyhank.service"]
+          : uid !== undefined
+            ? ["launchctl", "kickstart", "-k", `gui/${uid}/sh.heyhank.app`]
+            : ["launchctl", "kickstart", "-k", "sh.heyhank.app"];
+
+        Bun.spawn(restartCmd, {
+          stdout: "ignore",
+          stderr: "ignore",
+          stdin: "ignore",
+          env: isLinux
+            ? {
+                ...process.env,
+                XDG_RUNTIME_DIR:
+                  process.env.XDG_RUNTIME_DIR ||
+                  `/run/user/${uid ?? 1000}`,
+              }
+            : undefined,
+        });
+
+        setTimeout(() => process.exit(0), 500);
+      } catch (err) {
+        console.error("[update] Update failed:", err);
+        setUpdateInProgress(false);
+      }
+    }, 100);
+
+    return c.json({
+      ok: true,
+      message: "Update started. Server will restart shortly.",
+    });
+  });
+
+  api.get("/terminal", (c) => {
+    const terminalId = c.req.query("terminalId");
+    const info = deps.terminalManager.getInfo(terminalId || undefined);
+    if (!info) return c.json({ active: false });
+    return c.json({ active: true, terminalId: info.id, cwd: info.cwd });
+  });
+
+  api.post("/terminal/spawn", async (c) => {
+    const body = await c.req.json<{ cwd: string; cols?: number; rows?: number; containerId?: string }>();
+    if (!body.cwd) return c.json({ error: "cwd is required" }, 400);
+    const terminalId = deps.terminalManager.spawn(body.cwd, body.cols, body.rows, {
+      containerId: body.containerId,
+    });
+    return c.json({ terminalId });
+  });
+
+  api.post("/terminal/kill", async (c) => {
+    const body = await c.req.json<{ terminalId?: string }>().catch(() => undefined);
+    const terminalId = body?.terminalId?.trim();
+    if (!terminalId) return c.json({ error: "terminalId is required" }, 400);
+    deps.terminalManager.kill(terminalId);
+    return c.json({ ok: true });
+  });
+
+  api.post("/sessions/:id/message", async (c) => {
+    const id = c.req.param("id");
+    const session = deps.launcher.getSession(id);
+    if (!session) return c.json({ error: "Session not found" }, 404);
+    if (!deps.launcher.isAlive(id)) return c.json({ error: "Session is not running" }, 400);
+    const body = await c.req.json().catch(() => ({}));
+    if (typeof body.content !== "string" || !body.content.trim()) {
+      return c.json({ error: "content is required" }, 400);
+    }
+    deps.wsBridge.injectUserMessage(id, body.content);
+    return c.json({ ok: true, sessionId: id });
+  });
+}

package/server/routes/tailscale-routes.ts

@@ -0,0 +1,22 @@
+import type { Hono } from "hono";
+import { getTailscaleStatus, startFunnel, stopFunnel } from "../tailscale-manager.js";
+
+export function registerTailscaleRoutes(api: Hono, port: number): void {
+  api.get("/tailscale/status", async (c) => {
+    const status = await getTailscaleStatus(port);
+    return c.json(status);
+  });
+
+  // Always return 200 — the `error` and `needsOperatorMode` fields in the body
+  // signal failures. This lets the frontend receive the full structured status
+  // instead of the generic post() helper throwing and losing context.
+  api.post("/tailscale/funnel/start", async (c) => {
+    const status = await startFunnel(port);
+    return c.json(status);
+  });
+
+  api.post("/tailscale/funnel/stop", async (c) => {
+    const status = await stopFunnel(port);
+    return c.json(status);
+  });
+}