heyhank 0.1.0 → 0.2.0

package/server/session-creation-service.ts

@@ -108,7 +108,7 @@ export async function executeSessionCreation(
   // Resolve Docker image early
   let effectiveImage: string | null = null;
   if (sandboxEnabled) {
-    effectiveImage = "the-companion:latest";
+    effectiveImage = "heyhank:latest";
   } else if ((body.container as Record<string, unknown>)?.image) {
     effectiveImage = (body.container as Record<string, unknown>).image as string;
   }
@@ -269,7 +269,7 @@ export async function executeSessionCreation(
       ports: containerPorts,
       volumes: (body.container as Record<string, unknown>)?.volumes as string[] | undefined,
       env: { ...(envVars ?? {}), DISPLAY: ":99" },
-      privileged: sandboxEnabled && effectiveImage === "the-companion:latest",
+      privileged: sandboxEnabled && effectiveImage === "heyhank:latest",
     };
     try {
       containerInfo = containerManager.createContainer(tempId, cwd!, cConfig);

package/server/session-orchestrator.ts

@@ -19,6 +19,8 @@ import { generateSessionTitle } from "./auto-namer.js";
 import { heyHankBus } from "./event-bus.js";
 import { metricsCollector } from "./metrics-collector.js";
 import { log } from "./logger.js";
+import { authEvents, attemptRefresh } from "./claude-auth-monitor.js";
+import { deleteClaudeSessionTranscript } from "./claude-session-discovery.js";
 
 // ── Constants ────────────────────────────────────────────────────────────────
 
@@ -65,6 +67,7 @@ export interface CreateSessionRequest {
   container?: { image?: string; ports?: number[]; volumes?: string[] };
   resumeSessionAt?: string;
   forkSession?: boolean;
+  providerId?: string;
 }
 
 export type CreateSessionResult =
@@ -195,6 +198,26 @@ export class SessionOrchestrator {
       await this.handleAutoNaming(sessionId, firstUserMessage);
     });
 
+    // Subscribe to auth failure events for auto-fix orchestration
+    authEvents.on("auth:failure", async ({ sessionId }: { error: string; sessionId?: string }) => {
+      console.log(`[orchestrator] Auth failure detected${sessionId ? ` for session ${sessionId}` : ""}`);
+      const refreshed = await attemptRefresh();
+      if (refreshed && sessionId) {
+        // Try to relaunch the failed session
+        try {
+          const session = this.launcher.getSession(sessionId);
+          if (session && session.state === "exited") {
+            console.log(`[orchestrator] Relaunching session ${sessionId} after auth refresh`);
+            await this.handleAutoRelaunch(sessionId);
+          }
+        } catch (err) {
+          console.log(`[orchestrator] Failed to relaunch session after auth refresh: ${err}`);
+        }
+      } else if (!refreshed) {
+        authEvents.emit("auth:refresh-exhausted");
+      }
+    });
+
     // Reconnection watchdog for stale sessions after server restart
     this.startReconnectionWatchdog();
   }
@@ -274,7 +297,7 @@ export class SessionOrchestrator {
       // Resolve Docker image early
       let effectiveImage: string | null = null;
       if (sandboxEnabled) {
-        effectiveImage = "the-companion:latest";
+        effectiveImage = "heyhank:latest";
       } else if (body.container?.image) {
         effectiveImage = body.container.image;
       }
@@ -425,7 +448,7 @@ export class SessionOrchestrator {
           ports: containerPorts,
           volumes: body.container?.volumes,
           env: { ...(envVars ?? {}), DISPLAY: ":99" },
-          privileged: sandboxEnabled && effectiveImage === "the-companion:latest",
+          privileged: sandboxEnabled && effectiveImage === "heyhank:latest",
         };
         try {
           containerInfo = containerManager.createContainer(tempId, cwd!, cConfig);
@@ -628,6 +651,12 @@ export class SessionOrchestrator {
   // ── Delete ─────────────────────────────────────────────────────────────────
 
   async deleteSession(sessionId: string): Promise<DeleteSessionResult> {
+    // Capture CLI session info BEFORE removeSession() wipes it from memory —
+    // we need cliSessionId to find the Claude Code transcript on disk.
+    const sessionInfo = this.launcher.getSession(sessionId);
+    const cliSessionId = sessionInfo?.cliSessionId;
+    const backendType = sessionInfo?.backendType;
+
     await this.launcher.kill(sessionId);
     containerManager.removeContainer(sessionId);
     const worktreeResult = this.cleanupWorktree(sessionId, true);
@@ -637,6 +666,29 @@ export class SessionOrchestrator {
     this.autoRelaunchCounts.delete(sessionId);
     this.relaunchExhaustedNotified.delete(sessionId);
     this.relaunchingSet.delete(sessionId);
+
+    // Delete the Claude Code transcript file so the session does not reappear
+    // in the "Branch from session" picker via discoverClaudeSessions.
+    // Only applies to Claude Code (Codex stores its history elsewhere).
+    if (backendType === "claude" && cliSessionId) {
+      try {
+        const result = deleteClaudeSessionTranscript(cliSessionId);
+        if (result.deleted.length > 0) {
+          log.info("session-orchestrator", "deleted claude transcript", {
+            sessionId,
+            cliSessionId,
+            paths: result.deleted,
+          });
+        }
+      } catch (err) {
+        log.warn("session-orchestrator", "failed to delete claude transcript", {
+          sessionId,
+          cliSessionId,
+          err: err instanceof Error ? err.message : String(err),
+        });
+      }
+    }
+
     return { ok: true, worktree: worktreeResult };
   }
 

package/server/session-types.ts

@@ -430,6 +430,8 @@ export interface SessionState {
   nodeId?: string;
   /** Federation: remote node display name */
   nodeName?: string;
+  /** Raw message history kept for search (populated by ws-bridge) */
+  messageHistory?: Array<Record<string, unknown>>;
 }
 
 // ─── MCP Types ───────────────────────────────────────────────────────────────

package/server/settings-manager.ts

@@ -3,6 +3,7 @@ import {
   readFileSync,
   writeFileSync,
   existsSync,
+  renameSync,
 } from "node:fs";
 import { join, dirname } from "node:path";
 import { HEYHANK_HOME } from "./paths.js";
@@ -28,6 +29,20 @@ export interface HeyHankSettings {
   assistantName: string;
   /** User's display name so the assistant knows who it's talking to */
   userName: string;
+  /** Selected chat provider for Hank-UI (default: "gemini-live") */
+  hankChatProvider: string;
+  /** Selected model for Hank-UI text chat */
+  hankChatModel: string;
+  /** Whether to show a 3D TalkingHead avatar during Gemini Live sessions */
+  hankChatAvatarEnabled: boolean;
+  /** URL to a Ready Player Me (or compatible) GLB avatar with ARKit + Oculus visemes */
+  hankChatAvatarUrl: string;
+  /** @deprecated No longer used — memory is fully local */
+  mem0ApiKey: string;
+  /** @deprecated No longer used — memory is fully local */
+  mem0UserId: string;
+  /** Auto-detect and save memories from conversations */
+  memoryAutoDetect: boolean;
   editorTabEnabled: boolean;
   /** Provider ID for internal AI features (auto-renaming, AI validation). Empty = auto-detect. */
   internalAiProvider: string;
@@ -37,6 +52,8 @@ export interface HeyHankSettings {
   publicUrl: string;
   updateChannel: UpdateChannel;
   dockerAutoUpdate: boolean;
+  /** Path to Obsidian vault folder for memory sync (empty = disabled) */
+  obsidianVaultPath: string;
   updatedAt: number;
 }
 
@@ -54,6 +71,15 @@ let settings: HeyHankSettings = {
   geminiVoice: "Kore",
   assistantName: "",
   userName: "",
+  hankChatProvider: "gemini-live",
+  hankChatModel: "",
+  hankChatAvatarEnabled: true,
+  // No default URL: models.readyplayer.me was retired (DNS NXDOMAIN),
+  // so the user must paste a working GLB URL in Settings.
+  hankChatAvatarUrl: "",
+  mem0ApiKey: "",
+  mem0UserId: "",
+  memoryAutoDetect: true,
   editorTabEnabled: false,
   internalAiProvider: "",
   aiValidationEnabled: false,
@@ -62,6 +88,7 @@ let settings: HeyHankSettings = {
   publicUrl: "",
   updateChannel: "stable",
   dockerAutoUpdate: false,
+  obsidianVaultPath: "",
   updatedAt: 0,
 };
 
@@ -79,6 +106,16 @@ function normalize(raw: Partial<HeyHankSettings> | null | undefined): HeyHankSet
     geminiVoice: typeof raw?.geminiVoice === "string" && raw.geminiVoice.trim() ? raw.geminiVoice : "Kore",
     assistantName: typeof raw?.assistantName === "string" ? raw.assistantName.trim() : "",
     userName: typeof raw?.userName === "string" ? raw.userName.trim() : "",
+    hankChatProvider: typeof raw?.hankChatProvider === "string" ? raw.hankChatProvider.trim() || "gemini-live" : "gemini-live",
+    hankChatModel: typeof raw?.hankChatModel === "string" ? raw.hankChatModel.trim() : "",
+    hankChatAvatarEnabled: typeof raw?.hankChatAvatarEnabled === "boolean" ? raw.hankChatAvatarEnabled : true,
+    hankChatAvatarUrl:
+      typeof raw?.hankChatAvatarUrl === "string"
+        ? raw.hankChatAvatarUrl.trim()
+        : "",
+    mem0ApiKey: typeof raw?.mem0ApiKey === "string" ? raw.mem0ApiKey : "",
+    mem0UserId: typeof raw?.mem0UserId === "string" ? raw.mem0UserId.trim() : "",
+    memoryAutoDetect: typeof raw?.memoryAutoDetect === "boolean" ? raw.memoryAutoDetect : true,
     editorTabEnabled: typeof raw?.editorTabEnabled === "boolean" ? raw.editorTabEnabled : false,
     internalAiProvider: typeof raw?.internalAiProvider === "string" ? raw.internalAiProvider.trim() : "",
     aiValidationEnabled: typeof raw?.aiValidationEnabled === "boolean" ? raw.aiValidationEnabled : false,
@@ -87,6 +124,7 @@ function normalize(raw: Partial<HeyHankSettings> | null | undefined): HeyHankSet
     publicUrl: typeof raw?.publicUrl === "string" ? raw.publicUrl.trim().replace(/\/+$/, "") : "",
     updateChannel: raw?.updateChannel === "prerelease" ? "prerelease" : "stable",
     dockerAutoUpdate: typeof raw?.dockerAutoUpdate === "boolean" ? raw.dockerAutoUpdate : false,
+    obsidianVaultPath: typeof raw?.obsidianVaultPath === "string" ? raw.obsidianVaultPath.trim() : "",
     updatedAt: typeof raw?.updatedAt === "number" ? raw.updatedAt : 0,
   };
 }
@@ -106,7 +144,9 @@ function ensureLoaded(): void {
 
 function persist(): void {
   mkdirSync(dirname(filePath), { recursive: true });
-  writeFileSync(filePath, JSON.stringify(settings, null, 2), { encoding: "utf-8", mode: 0o600 });
+  const tmpFile = filePath + ".tmp";
+  writeFileSync(tmpFile, JSON.stringify(settings, null, 2), { encoding: "utf-8", mode: 0o600 });
+  renameSync(tmpFile, filePath);
 }
 
 export function getSettings(): HeyHankSettings {
@@ -115,7 +155,7 @@ export function getSettings(): HeyHankSettings {
 }
 
 export function updateSettings(
-  patch: Partial<Pick<HeyHankSettings, "anthropicApiKey" | "anthropicModel" | "claudeCodeOAuthToken" | "openaiApiKey" | "onboardingCompleted" | "geminiApiKey" | "geminiVoice" | "assistantName" | "userName" | "editorTabEnabled" | "internalAiProvider" | "aiValidationEnabled" | "aiValidationAutoApprove" | "aiValidationAutoDeny" | "publicUrl" | "updateChannel" | "dockerAutoUpdate">>,
+  patch: Partial<Pick<HeyHankSettings, "anthropicApiKey" | "anthropicModel" | "claudeCodeOAuthToken" | "openaiApiKey" | "onboardingCompleted" | "geminiApiKey" | "geminiVoice" | "assistantName" | "userName" | "hankChatProvider" | "hankChatModel" | "hankChatAvatarEnabled" | "hankChatAvatarUrl" | "mem0ApiKey" | "mem0UserId" | "memoryAutoDetect" | "editorTabEnabled" | "internalAiProvider" | "aiValidationEnabled" | "aiValidationAutoApprove" | "aiValidationAutoDeny" | "publicUrl" | "updateChannel" | "dockerAutoUpdate" | "obsidianVaultPath">>,
 ): HeyHankSettings {
   ensureLoaded();
   settings = normalize({
@@ -128,6 +168,13 @@ export function updateSettings(
     geminiVoice: patch.geminiVoice ?? settings.geminiVoice,
     assistantName: patch.assistantName ?? settings.assistantName,
     userName: patch.userName ?? settings.userName,
+    hankChatProvider: patch.hankChatProvider ?? settings.hankChatProvider,
+    hankChatModel: patch.hankChatModel ?? settings.hankChatModel,
+    hankChatAvatarEnabled: patch.hankChatAvatarEnabled ?? settings.hankChatAvatarEnabled,
+    hankChatAvatarUrl: patch.hankChatAvatarUrl ?? settings.hankChatAvatarUrl,
+    mem0ApiKey: patch.mem0ApiKey ?? settings.mem0ApiKey,
+    mem0UserId: patch.mem0UserId ?? settings.mem0UserId,
+    memoryAutoDetect: patch.memoryAutoDetect ?? settings.memoryAutoDetect,
     editorTabEnabled: patch.editorTabEnabled ?? settings.editorTabEnabled,
     internalAiProvider: patch.internalAiProvider ?? settings.internalAiProvider,
     aiValidationEnabled: patch.aiValidationEnabled ?? settings.aiValidationEnabled,
@@ -136,6 +183,7 @@ export function updateSettings(
     publicUrl: patch.publicUrl ?? settings.publicUrl,
     updateChannel: patch.updateChannel ?? settings.updateChannel,
     dockerAutoUpdate: patch.dockerAutoUpdate ?? settings.dockerAutoUpdate,
+    obsidianVaultPath: patch.obsidianVaultPath ?? settings.obsidianVaultPath,
     updatedAt: Date.now(),
   });
   persist();

package/server/skill-discovery.ts

@@ -0,0 +1,68 @@
+// ─── Skill Discovery ────────────────────────────────────────────────────────
+// Lists installed Claude Code skills under ~/.claude/skills/ with their
+// metadata (slug, name, description) so HankChat and other layers can route
+// requests to a matching skill without spawning a Claude Code session.
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+export interface InstalledSkill {
+  /** Directory name (and slug Claude Code uses to invoke). */
+  slug: string;
+  /** Display name from frontmatter (falls back to slug). */
+  name: string;
+  /** When-to-use description from frontmatter (empty string if missing). */
+  description: string;
+}
+
+/** Parse the `name:` and `description:` fields from a SKILL.md frontmatter. */
+function parseFrontmatter(content: string): { name?: string; description?: string } {
+  const m = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!m) return {};
+  const out: { name?: string; description?: string } = {};
+  for (const line of m[1].split("\n")) {
+    const nameMatch = line.match(/^name:\s*["']?(.+?)["']?\s*$/);
+    if (nameMatch) out.name = nameMatch[1].trim();
+    const descMatch = line.match(/^description:\s*["']?(.+?)["']?\s*$/);
+    if (descMatch) out.description = descMatch[1].trim();
+  }
+  return out;
+}
+
+/** Read raw SKILL.md content for a given slug, or null when missing/unreadable. */
+export function readSkillContent(slug: string): string | null {
+  if (!/^[a-zA-Z0-9._-]+$/.test(slug)) return null;
+  const path = join(homedir(), ".claude", "skills", slug, "SKILL.md");
+  if (!existsSync(path)) return null;
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+/** Enumerate installed skills with their frontmatter metadata. */
+export function listInstalledSkills(): InstalledSkill[] {
+  const skillsDir = join(homedir(), ".claude", "skills");
+  if (!existsSync(skillsDir)) return [];
+  const out: InstalledSkill[] = [];
+  let entries: string[] = [];
+  try {
+    entries = readdirSync(skillsDir);
+  } catch {
+    return [];
+  }
+  for (const slug of entries) {
+    const content = readSkillContent(slug);
+    if (!content) continue;
+    const fm = parseFrontmatter(content);
+    out.push({
+      slug,
+      name: fm.name || slug,
+      description: fm.description || "",
+    });
+  }
+  out.sort((a, b) => a.slug.localeCompare(b.slug));
+  return out;
+}

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

@@ -0,0 +1,179 @@
+// ─── Browser Adapter ─────────────────────────────────────────────────────────
+// Posts to X (Twitter) and TikTok by driving the persistent Playwright context
+// managed by SocialView (server/socialview/browser-manager.ts). User logs in
+// once manually via noVNC; cookies persist in
+// ~/.heyhank/browser-profiles/<platform>.
+//
+// Scope v1:
+//   - X:      text + optional single image
+//   - TikTok: video + description
+// Analytics, comments, reply, list, delete are not supported here.
+
+import type { SocialMediaAdapter } from "../adapter.js";
+import type {
+  SocialProfile,
+  CreatePostInput,
+  PostAnalytics,
+  AccountAnalytics,
+  SocialComment,
+  SocialPlatform,
+} from "../types.js";
+import * as browser from "../../socialview/browser-manager.js";
+import type { SocialPlatform as ViewPlatform } from "../../socialview/types.js";
+import { postToTiktok, postToX, resolveMediaToDiskPath } from "../../socialview/poster.js";
+
+// Subset of both the socialmedia and socialview SocialPlatform unions.
+type BrowserBackedPlatform = Extract<SocialPlatform, "twitter" | "tiktok"> & ViewPlatform;
+const SUPPORTED: BrowserBackedPlatform[] = ["twitter", "tiktok"];
+
+export class BrowserAdapter implements SocialMediaAdapter {
+  /**
+   * Target platforms for a single `createPost` call. Set by the manager
+   * before calling so we don't accidentally post to both X and TikTok when
+   * only one was requested.
+   */
+  private targetPlatforms: BrowserBackedPlatform[] = [];
+
+  setTargetPlatforms(platforms: SocialPlatform[]): void {
+    this.targetPlatforms = platforms.filter(
+      (p): p is BrowserBackedPlatform => (SUPPORTED as readonly SocialPlatform[]).includes(p),
+    );
+  }
+
+  supportedPlatforms(): SocialPlatform[] {
+    return [...SUPPORTED];
+  }
+
+  async testConnection(): Promise<{ ok: boolean; error?: string; data?: unknown }> {
+    const results: Record<string, { running: boolean; loggedIn: boolean | null }> = {};
+    const failures: string[] = [];
+    for (const p of SUPPORTED) {
+      const status = browser.getStatus(p);
+      results[p] = { running: status.running, loggedIn: status.loggedIn };
+      if (!status.running) failures.push(`${p}: browser not running`);
+      else if (status.loggedIn === false) failures.push(`${p}: not logged in`);
+    }
+    if (failures.length > 0) {
+      return { ok: false, error: failures.join("; "), data: results };
+    }
+    return { ok: true, data: results };
+  }
+
+  async getProfiles(): Promise<SocialProfile[]> {
+    // v1: we don't read the actual handle from the DOM. Report a placeholder
+    // per running+loggedIn platform so the UI at least shows a profile card.
+    const out: SocialProfile[] = [];
+    for (const p of SUPPORTED) {
+      const status = browser.getStatus(p);
+      if (status.running && status.loggedIn !== false) {
+        out.push({
+          id: `browser:${p}`,
+          platform: p,
+          name: `${p}-browser`,
+          picture: null,
+        });
+      }
+    }
+    return out;
+  }
+
+  async createPost(
+    input: CreatePostInput,
+  ): Promise<{ id: string | null; status: string; backendData?: unknown }> {
+    const platforms: BrowserBackedPlatform[] = this.targetPlatforms.length > 0
+      ? this.targetPlatforms
+      : input.platforms.filter(
+          (p): p is BrowserBackedPlatform => (SUPPORTED as readonly SocialPlatform[]).includes(p),
+        );
+
+    if (platforms.length === 0) {
+      return {
+        id: null,
+        status: "failed",
+        backendData: { error: "BrowserAdapter called with no supported platforms" },
+      };
+    }
+
+    const results: Record<string, { ok: boolean; url: string | null; error?: string }> = {};
+    let anyOk = false;
+    let anyFail = false;
+
+    for (const platform of platforms) {
+      try {
+        // Ensure the persistent Chromium is running for this platform.
+        const status = browser.getStatus(platform);
+        if (!status.running) await browser.startPlatform(platform);
+
+        const page = browser.getPage(platform);
+        if (!page) throw new Error(`${platform}: browser page unavailable`);
+        if (browser.getStatus(platform).loggedIn === false) {
+          throw new Error(`${platform}: not logged in — open browser in SocialView and sign in`);
+        }
+
+        if (platform === "tiktok") {
+          // TikTok requires a video. Prefer videoUrl, fall back to first mediaUrl.
+          const videoUrl = input.videoUrl || (input.mediaUrls ?? [])[0];
+          if (!videoUrl) throw new Error("tiktok: videoUrl (or mediaUrls[0]) required");
+          const videoPath = await resolveMediaToDiskPath(videoUrl);
+          const r = await postToTiktok(page, {
+            description: input.text,
+            videoPath,
+          });
+          results[platform] = { ok: true, url: r.url };
+          anyOk = true;
+        } else if (platform === "twitter") {
+          // X: text + optional single image. v1 takes only mediaUrls[0].
+          const firstMedia = (input.mediaUrls ?? [])[0];
+          const imagePath = firstMedia ? await resolveMediaToDiskPath(firstMedia) : undefined;
+          const r = await postToX(page, { text: input.text, imagePath });
+          results[platform] = { ok: true, url: r.url };
+          anyOk = true;
+        } else {
+          results[platform] = { ok: false, url: null, error: "unsupported" };
+          anyFail = true;
+        }
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        results[platform] = { ok: false, url: null, error: message };
+        anyFail = true;
+      }
+    }
+
+    const status = anyOk && anyFail ? "partial" : anyOk ? "published" : "failed";
+    // Pick a primary URL (first success) for the flat `id` slot; detailed
+    // per-platform results go in backendData.
+    const primary = platforms
+      .map((p) => results[p])
+      .find((r) => r?.ok && r.url)?.url ?? null;
+
+    return {
+      id: primary,
+      status,
+      backendData: { results },
+    };
+  }
+
+  async listPosts(): Promise<Array<{ id: string; text: string; status: string; platforms: string[]; createdAt?: string | null; scheduledAt?: string | null }>> {
+    return [];
+  }
+
+  async deletePost(_postId: string): Promise<boolean> {
+    return false;
+  }
+
+  async getAnalytics(_postId: string): Promise<PostAnalytics> {
+    return { impressions: 0, likes: 0, shares: 0, comments: 0 };
+  }
+
+  async getAccountAnalytics(_profileId: string): Promise<AccountAnalytics> {
+    return { followers: 0, following: 0, posts: 0 };
+  }
+
+  async getComments(_postId: string): Promise<SocialComment[]> {
+    return [];
+  }
+
+  async replyToComment(_postId: string, _commentId: string | null, _text: string): Promise<{ ok: boolean; error?: string }> {
+    return { ok: false, error: "not supported" };
+  }
+}