fix: persist session binding to disk to survive restarts

Addresses bot feedback on PR #1171: the in-memory session binding was
bypassed by simply restarting the CLI process. Now the binding is
persisted to ~/.config/manicode/session-binding.json alongside the
session lifecycle:

- Persisted when session becomes active
- Loaded on startup and restored to in-memory state
- Cleared when session ends or on force-logout
- Checked on startup against current credentials

This closes the restart-bypass abuse path: a user who Ctrl-C's and
restarts with different credentials will hit the startup guard, which
reads the persisted binding and ends the session if the user changed.

Author: Dataflow Dev

cli/src/commands/command-registry.ts

@@ -18,6 +18,7 @@ import {
   getSessionBoundUserId,
 } from '../hooks/use-freebuff-session'
 import { releaseFreebuffSlot } from '../utils/freebuff-session-api'
+import { clearSessionBinding } from '../utils/session-binding'
 import { useFreebuffSessionStore } from '../state/freebuff-session-store'
 import { useThemeStore } from '../hooks/use-theme'
 import { LOGIN_WEBSITE_URL, WEBSITE_URL } from '../login/constants'
@@ -322,6 +323,7 @@ const ALL_COMMANDS: CommandDefinition[] = [
       if (boundUserId && force) {
         releaseFreebuffSlot().catch(() => {})
         useFreebuffSessionStore.getState().setSessionBoundUserId(null)
+        clearSessionBinding()
       }
 
       const { resetLoginState } = useLoginStore.getState()

cli/src/hooks/use-auth-state.ts

@@ -9,6 +9,7 @@ import { clearUserCredentials, getUserCredentials } from '../utils/auth'
 import { resetCodebuffClient } from '../utils/codebuff-client'
 import { IS_FREEBUFF } from '../utils/constants'
 import { logger, loggerContext } from '../utils/logger'
+import { clearSessionBinding } from '../utils/session-binding'
 
 import type { MultilineInputHandle } from '../components/multiline-input'
 import type { User } from '../utils/auth'

cli/src/hooks/use-freebuff-session.ts

@@ -27,6 +27,11 @@ import {
   recordFreebuffInstanceOwner,
 } from '../utils/freebuff-instance-owner'
 import { logger } from '../utils/logger'
+import {
+  clearSessionBinding,
+  persistSessionBinding,
+  readSessionBinding,
+} from '../utils/session-binding'
 import { getSystemMessage } from '../utils/message-history'
 import {
   clearReferralCache,
@@ -425,17 +430,21 @@ export function useFreebuffSession(): UseFreebuffSessionResult {
 
     // Startup guard: if a session is bound to a different user, end it
     // immediately to prevent multi-account abuse on the same machine.
-    const { sessionBoundUserId } = useFreebuffSessionStore.getState()
+    // Check both in-memory state and persisted binding (survives restarts).
+    const inMemoryBoundUserId = useFreebuffSessionStore.getState().sessionBoundUserId
+    const persistedBoundUserId = readSessionBinding()
+    const boundUserId = inMemoryBoundUserId ?? persistedBoundUserId
     const currentUser = getUserCredentials()
-    if (sessionBoundUserId && currentUser?.id !== sessionBoundUserId) {
+    if (boundUserId && currentUser?.id !== boundUserId) {
       logger.warn(
         {
-          sessionBoundUserId,
+          sessionBoundUserId: boundUserId,
           currentUserId: currentUser?.id,
         },
         '[freebuff-session] Session bound to different user; ending session',
       )
       useFreebuffSessionStore.getState().setSessionBoundUserId(null)
+      clearSessionBinding()
       releaseFreebuffSlot().catch(() => {})
       setSession({
         status: 'ended',
@@ -446,6 +455,14 @@ export function useFreebuffSession(): UseFreebuffSessionResult {
       return
     }
 
+    // If we have a persisted binding but no in-memory state (e.g. after restart),
+    // restore the binding so the guard works on the next startup too.
+    if (persistedBoundUserId && !inMemoryBoundUserId) {
+      useFreebuffSessionStore
+        .getState()
+        .setSessionBoundUserId(persistedBoundUserId)
+    }
+
     let cancelled = false
     let abortController = new AbortController()
     let timer: ReturnType<typeof setTimeout> | null = null
@@ -474,11 +491,13 @@ export function useFreebuffSession(): UseFreebuffSessionResult {
       if (next.status === 'active') {
         recordFreebuffInstanceOwner(next.instanceId)
         // Bind the session to the current user to prevent multi-account abuse.
+        // Persist to disk so the binding survives process restarts.
         const credentials = getUserCredentials()
         if (credentials?.id) {
           useFreebuffSessionStore
             .getState()
             .setSessionBoundUserId(credentials.id)
+          persistSessionBinding(credentials.id)
         }
       } else if (
         next.status === 'ended' ||
@@ -487,6 +506,7 @@ export function useFreebuffSession(): UseFreebuffSessionResult {
       ) {
         // Clear the binding when the session is no longer active.
         useFreebuffSessionStore.getState().setSessionBoundUserId(null)
+        clearSessionBinding()
       }
       setSession(next)
       setFailure(null)

cli/src/utils/__tests__/session-binding.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import fs from 'fs'
+
+import { getConfigDir } from '../auth'
+import {
+  persistSessionBinding,
+  readSessionBinding,
+  clearSessionBinding,
+} from '../session-binding'
+
+const getBindingPath = () =>
+  require('path').join(getConfigDir(), 'session-binding.json')
+
+describe('session-binding persistence', () => {
+  const bindingPath = getBindingPath()
+
+  beforeEach(() => {
+    try {
+      fs.mkdirSync(getConfigDir(), { recursive: true })
+    } catch {
+      // ignore
+    }
+    try {
+      fs.unlinkSync(bindingPath)
+    } catch {
+      // ignore
+    }
+  })
+
+  afterEach(() => {
+    try {
+      fs.unlinkSync(bindingPath)
+    } catch {
+      // ignore
+    }
+  })
+
+  it('readSessionBinding returns null when no file exists', () => {
+    expect(readSessionBinding()).toBeNull()
+  })
+
+  it('persistSessionBinding writes a JSON file with userId', () => {
+    persistSessionBinding('user-abc')
+
+    const raw = fs.readFileSync(bindingPath, 'utf8')
+    const parsed = JSON.parse(raw)
+    expect(parsed.userId).toBe('user-abc')
+  })
+
+  it('readSessionBinding reads back the persisted userId', () => {
+    persistSessionBinding('user-abc')
+    expect(readSessionBinding()).toBe('user-abc')
+  })
+
+  it('persistSessionBinding overwrites previous binding', () => {
+    persistSessionBinding('user-abc')
+    persistSessionBinding('user-xyz')
+
+    expect(readSessionBinding()).toBe('user-xyz')
+  })
+
+  it('clearSessionBinding removes the file', () => {
+    persistSessionBinding('user-abc')
+    clearSessionBinding()
+
+    expect(fs.existsSync(bindingPath)).toBe(false)
+    expect(readSessionBinding()).toBeNull()
+  })
+
+  it('clearSessionBinding is idempotent', () => {
+    persistSessionBinding('user-abc')
+    clearSessionBinding()
+    clearSessionBinding() // second call should not throw
+
+    expect(readSessionBinding()).toBeNull()
+  })
+
+  it('readSessionBinding returns null for malformed JSON', () => {
+    fs.writeFileSync(bindingPath, 'not-json')
+    expect(readSessionBinding()).toBeNull()
+  })
+
+  it('readSessionBinding returns null when userId is missing', () => {
+    fs.writeFileSync(bindingPath, JSON.stringify({ other: 'data' }))
+    expect(readSessionBinding()).toBeNull()
+  })
+})

cli/src/utils/session-binding.ts

@@ -0,0 +1,65 @@
+import fs from 'fs'
+import path from 'path'
+
+import { getConfigDir } from './auth'
+import { logger } from './logger'
+
+const SESSION_BINDING_FILE = 'session-binding.json'
+
+interface SessionBinding {
+  userId: string
+}
+
+const getBindingPath = (): string =>
+  path.join(getConfigDir(), SESSION_BINDING_FILE)
+
+/**
+ * Persist the session-bound user id to disk so it survives process restarts.
+ * Without this, a user could Ctrl-C and restart the CLI to clear the in-memory
+ * binding and switch accounts.
+ */
+export function persistSessionBinding(userId: string): void {
+  try {
+    fs.mkdirSync(getConfigDir(), { recursive: true })
+    fs.writeFileSync(
+      getBindingPath(),
+      JSON.stringify({ userId } satisfies SessionBinding, null, 2),
+    )
+  } catch (error) {
+    logger.debug(
+      { error: error instanceof Error ? error.message : String(error) },
+      '[session-binding] Failed to persist binding',
+    )
+  }
+}
+
+/**
+ * Read the persisted session-bound user id from disk. Returns null if no
+ * binding exists or the file is malformed.
+ */
+export function readSessionBinding(): string | null {
+  try {
+    const raw = fs.readFileSync(getBindingPath(), 'utf8')
+    const parsed = JSON.parse(raw) as Partial<SessionBinding>
+    if (typeof parsed.userId !== 'string') return null
+    return parsed.userId
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Clear the persisted session binding from disk.
+ */
+export function clearSessionBinding(): void {
+  try {
+    if (fs.existsSync(getBindingPath())) {
+      fs.unlinkSync(getBindingPath())
+    }
+  } catch (error) {
+    logger.debug(
+      { error: error instanceof Error ? error.message : String(error) },
+      '[session-binding] Failed to clear binding',
+    )
+  }
+}