bazilion 0.0.0

package/apps/cli/test/profile.test.ts

@@ -0,0 +1,110 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest'
+import { startTestServer, type TestServer } from './server-fixture.ts'
+
+let server: TestServer
+beforeAll(async () => {
+  server = await startTestServer()
+})
+afterAll(() => server.stop())
+beforeEach(() => server.reset())
+
+test('profile create + list + show', async () => {
+  let r = await server.cli([
+    'profile',
+    'create',
+    'researcher',
+    '--model',
+    'anthropic:claude-opus-4-6',
+    '--skills-mode',
+    'selected',
+    '--skills',
+    's1,s2',
+  ])
+  expect(r.exitCode).toBe(0)
+  expect(r.stdout).toContain('created profile researcher')
+
+  r = await server.cli(['profile', 'list'])
+  expect(r.stdout).toContain('researcher')
+  expect(r.stdout).toContain('claude-opus-4-6')
+
+  r = await server.cli(['profile', 'show', 'researcher'])
+  expect(r.stdout).toContain('researcher')
+  expect(r.stdout).toContain('default skills: s1, s2')
+  expect(r.stdout).toContain('skills mode:    selected')
+  expect(r.stdout).toContain('bootstrap: yes')
+})
+
+test('profile create with invalid slug fails', async () => {
+  const r = await server.cli(['profile', 'create', 'Bad Id', '--model', 'm'])
+  expect(r.exitCode).not.toBe(0)
+  expect(r.stderr + r.stdout).toContain('invalid slug')
+})
+
+test('profile update switches model and skills-mode', async () => {
+  await server.cli(['profile', 'create', 'to-update', '--model', 'anthropic:claude-opus-4-6'])
+  const r = await server.cli([
+    'profile',
+    'update',
+    'to-update',
+    '--model',
+    'anthropic:claude-opus-4-7',
+    '--skills-mode',
+    'all',
+  ])
+  expect(r.exitCode).toBe(0)
+  const show = await server.cli(['profile', 'show', 'to-update'])
+  expect(show.stdout).toContain('claude-opus-4-7')
+  expect(show.stdout).toContain('skills mode:    all')
+
+  const json = JSON.parse(
+    readFileSync(join(server.home, 'profiles', 'to-update', 'profile.json'), 'utf8'),
+  )
+  expect(json.defaultModel).toBe('anthropic:claude-opus-4-7')
+  expect(json.skillsMode).toBe('all')
+})
+
+test('PUT /api/profiles/:id/files/:file edits SOUL.md post-creation', async () => {
+  await server.cli(['profile', 'create', 'editable', '--model', 'anthropic:claude-opus-4-6'])
+  const res = await fetch(`${server.url}/api/profiles/editable/files/SOUL.md`, {
+    method: 'PUT',
+    headers: {
+      'content-type': 'application/json',
+      cookie: `bz_token=${server.token}`,
+      origin: server.url,
+    },
+    body: JSON.stringify({ content: '# edited post-creation\nnew rules' }),
+  })
+  expect(res.status).toBe(204)
+  const soul = readFileSync(join(server.home, 'profiles', 'editable', 'SOUL.md'), 'utf8')
+  expect(soul).toBe('# edited post-creation\nnew rules')
+})
+
+test('profile create --soul-file and --skip-bootstrap write custom templates', async () => {
+  const scratch = mkdtempSync(join(tmpdir(), 'bazilion-tmpl-'))
+  const soulPath = join(scratch, 'soul.md')
+  writeFileSync(soulPath, '# custom soul\nmake it yours')
+  try {
+    const r = await server.cli([
+      'profile',
+      'create',
+      'custom-tmpl',
+      '--model',
+      'anthropic:claude-opus-4-6',
+      '--soul-file',
+      soulPath,
+      '--skip-bootstrap',
+    ])
+    expect(r.exitCode).toBe(0)
+
+    const soul = readFileSync(join(server.home, 'profiles', 'custom-tmpl', 'SOUL.md'), 'utf8')
+    expect(soul).toBe('# custom soul\nmake it yours')
+
+    const show = await server.cli(['profile', 'show', 'custom-tmpl'])
+    expect(show.stdout).toContain('bootstrap: no')
+  } finally {
+    rmSync(scratch, { recursive: true, force: true })
+  }
+})

package/apps/cli/test/send.test.ts

@@ -0,0 +1,30 @@
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest'
+import { extractAgentId } from './helpers.ts'
+import { startTestServer, type TestServer } from './server-fixture.ts'
+
+let server: TestServer
+beforeAll(async () => {
+  server = await startTestServer()
+})
+afterAll(() => server.stop())
+beforeEach(() => server.reset())
+
+test('send writes a message between two agents', async () => {
+  await server.cli(['profile', 'create', 'p', '--model', 'm'])
+
+  let r = await server.cli(['agent', 'spawn', '--profile', 'p'])
+  const a = extractAgentId(r.stdout)
+  r = await server.cli(['agent', 'spawn', '--profile', 'p'])
+  const b = extractAgentId(r.stdout)
+
+  r = await server.cli(['send', a, b, 'hello there'])
+  expect(r.exitCode).toBe(0)
+  expect(r.stdout).toContain('sent message')
+})
+
+test('send fails when an agent is missing', async () => {
+  await server.cli(['profile', 'create', 'p', '--model', 'm'])
+  const r = await server.cli(['send', 'nope1', 'nope2', 'hi'])
+  expect(r.exitCode).not.toBe(0)
+  expect(r.stderr + r.stdout).toContain('agent not found')
+})

package/apps/cli/test/server-fixture.ts

@@ -0,0 +1,212 @@
+import { type ChildProcess, spawn } from 'node:child_process'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { createServer } from 'node:net'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import {
+  openDb,
+  providerModelRepo,
+  providerStateRepo,
+  registerGroup,
+  resolvePaths,
+  runMigrations,
+  webTokenRepo,
+} from '../../daemon/src/core/index.ts'
+import { type CliResult, runCli } from './helpers.ts'
+
+// Tests now boot the standalone daemon (apps/daemon/src/index.ts) — the
+// authority for /api/* — instead of the Astro web app, which only renders
+// pages and proxies to the daemon. tsx loader keeps the source-mode
+// invocation matching `bazilion serve`.
+const daemonEntry = join(import.meta.dirname, '..', '..', 'daemon', 'src', 'index.ts')
+
+function findFreePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const srv = createServer()
+    srv.listen(0, () => {
+      const addr = srv.address()
+      if (!addr || typeof addr === 'string') {
+        reject(new Error('unexpected server address'))
+        return
+      }
+      const port = addr.port
+      srv.close((err) => (err ? reject(err) : resolve(port)))
+    })
+    srv.on('error', reject)
+  })
+}
+
+/**
+ * Create a fresh `~/.bazilion`-shaped home: tempdir + subdirs + migrated db +
+ * a bootstrap token row in `web_tokens` + an `auth.json` exposing the
+ * plaintext for the CLI to use as a bearer. Mirrors the daemon's first-run
+ * bootstrap (`apps/daemon/src/lib/ctx.ts:bootstrap`) without the subprocess
+ * overhead.
+ */
+function initHome(): { home: string; token: string } {
+  const home = mkdtempSync(join(tmpdir(), 'bazilion-test-'))
+  const paths = resolvePaths(home)
+  for (const d of [
+    paths.home,
+    paths.profilesDir,
+    paths.agentsDir,
+    paths.skillsDir,
+    paths.groupsDir,
+    paths.logsDir,
+  ]) {
+    mkdirSync(d, { recursive: true })
+  }
+  const db = openDb(paths.db)
+  runMigrations(db)
+  // Mint a bootstrap token row + write its plaintext into auth.json.
+  const created = webTokenRepo.create(db, 'bootstrap')
+  writeFileSync(paths.authFile, `${JSON.stringify({ token: created.token }, null, 2)}\n`)
+  // Enable lmstudio + ollama by default for test setup — the integration
+  // tests mount their mock server via LMSTUDIO_URL and expect model resolution
+  // to succeed. Real installs default to all providers disabled and require
+  // the admin to toggle them on via /config.
+  providerStateRepo.setEnabled(db, 'lmstudio', true)
+  providerStateRepo.setEnabled(db, 'ollama', true)
+  // Curate a placeholder model so the first-run middleware gate sees setup
+  // as complete (isSetupComplete = any enabled provider has ≥1 curated model).
+  // Tests that care about a specific model still override via --model.
+  providerModelRepo.replace(db, 'lmstudio', ['test-model'])
+  providerModelRepo.replace(db, 'ollama', ['test-model'])
+  // Seed the 'default' group so spawnAgent's default-group fallback works
+  // without tests having to register one first. Matches the fresh-install
+  // post-first-run-setup state.
+  registerGroup(db, { id: 'default', name: 'Default' }, paths)
+  db.close()
+  return { home, token: created.token }
+}
+
+async function waitForHttp(url: string, timeoutMs: number): Promise<void> {
+  const start = Date.now()
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await fetch(url)
+      if (res.status >= 200 && res.status < 500) return
+    } catch {
+      // server not yet listening
+    }
+    await new Promise((r) => setTimeout(r, 150))
+  }
+  throw new Error(`timeout waiting for ${url}`)
+}
+
+export interface TestServer {
+  home: string
+  url: string
+  token: string
+  /** Run the CLI as a subprocess against this test server. */
+  cli(args: string[], extraEnv?: NodeJS.ProcessEnv): Promise<CliResult>
+  /**
+   * Wipe per-test state (DB rows + on-disk profiles/agents/skills/groups dirs)
+   * so the same daemon process can host multiple tests. Lets test files use
+   * `beforeAll(start)` + `beforeEach(reset)` instead of paying daemon cold
+   * start per test. The server's cached DB handle reads the post-reset state
+   * immediately because SQLite WAL + same file. Preserves the bootstrap
+   * web_tokens row so the CLI's bearer keeps working across tests.
+   */
+  reset(): void
+  stop(): Promise<void>
+}
+
+const WIPE_SQL = `
+  DELETE FROM messages;
+  DELETE FROM agent_triggers;
+  DELETE FROM agent_skills;
+  DELETE FROM agents;
+  DELETE FROM profile_default_skills;
+  DELETE FROM profiles;
+  DELETE FROM groups;
+  DELETE FROM skill_meta;
+  DELETE FROM provider_models;
+  DELETE FROM provider_state;
+  DELETE FROM secrets;
+  DELETE FROM config;
+`
+
+function resetHome(home: string): void {
+  const paths = resolvePaths(home)
+  const db = openDb(paths.db)
+  db.raw.exec(WIPE_SQL)
+  // Re-enable lmstudio + ollama the same way initHome does — tests that mount
+  // mock providers expect these enabled.
+  providerStateRepo.setEnabled(db, 'lmstudio', true)
+  providerStateRepo.setEnabled(db, 'ollama', true)
+  // Re-curate the placeholder model so the first-run gate stays open.
+  providerModelRepo.replace(db, 'lmstudio', ['test-model'])
+  providerModelRepo.replace(db, 'ollama', ['test-model'])
+  // Wipe + re-create the groups directory so the auto-seeded slot is fresh.
+  rmSync(paths.groupsDir, { recursive: true, force: true })
+  mkdirSync(paths.groupsDir, { recursive: true })
+  registerGroup(db, { id: 'default', name: 'Default' }, paths)
+  db.close()
+  for (const dir of [paths.profilesDir, paths.agentsDir, paths.skillsDir]) {
+    rmSync(dir, { recursive: true, force: true })
+    mkdirSync(dir, { recursive: true })
+  }
+}
+
+/**
+ * Spawns the daemon on a free port with BAZILION_HOME pointing at a fresh
+ * tempdir. Resolves once the server answers HTTP. Call `stop()` to kill the
+ * process and clean up the tempdir.
+ *
+ * Additional env vars can be passed (e.g. `LMSTUDIO_URL` pointing at a mock
+ * provider) — they're merged into the server's env.
+ */
+export async function startTestServer(extraServerEnv: NodeJS.ProcessEnv = {}): Promise<TestServer> {
+  const { home, token } = initHome()
+  const port = await findFreePort()
+  const url = `http://127.0.0.1:${port}`
+
+  const proc: ChildProcess = spawn('node', ['--import', 'tsx/esm', daemonEntry], {
+    env: {
+      ...process.env,
+      BAZILION_HOME: home,
+      HOST: '127.0.0.1',
+      PORT: String(port),
+      ...extraServerEnv,
+    },
+    stdio: 'ignore',
+  })
+
+  try {
+    // /api/health is unauthenticated — perfect liveness probe. Daemon should
+    // come up in well under a second; 20s is paranoia headroom.
+    await waitForHttp(`${url}/api/health`, 20_000)
+  } catch (err) {
+    proc.kill()
+    rmSync(home, { recursive: true, force: true })
+    throw err
+  }
+
+  return {
+    home,
+    url,
+    token,
+    cli(args, extraEnv = {}) {
+      return runCli(args, home, {
+        BAZILION_SERVER: url,
+        BAZILION_TOKEN: token,
+        ...extraEnv,
+      })
+    },
+    reset() {
+      resetHome(home)
+    },
+    async stop() {
+      await new Promise<void>((resolve) => {
+        proc.on('close', () => resolve())
+        proc.kill('SIGTERM')
+        // Failsafe: if the process hasn't exited in 5s, force it.
+        setTimeout(() => {
+          if (proc.exitCode === null) proc.kill('SIGKILL')
+        }, 5_000)
+      })
+      rmSync(home, { recursive: true, force: true })
+    },
+  }
+}

package/apps/cli/test/session-head.test.ts

@@ -0,0 +1,45 @@
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest'
+import { extractAgentId } from './helpers.ts'
+import { startTestServer, type TestServer } from './server-fixture.ts'
+
+let server: TestServer
+beforeAll(async () => {
+  server = await startTestServer({ BAZILION_SCHEDULER: 'off' })
+})
+afterAll(() => server.stop())
+beforeEach(() => server.reset())
+
+test('agent session-head reports (no session yet) for a fresh agent', async () => {
+  let r = await server.cli(['profile', 'create', 'p', '--model', 'anthropic:claude-opus-4-6'])
+  expect(r.exitCode).toBe(0)
+
+  r = await server.cli(['agent', 'spawn', '--profile', 'p', '--name', 'A'])
+  expect(r.exitCode).toBe(0)
+  const agentId = extractAgentId(r.stdout)
+
+  r = await server.cli(['agent', 'session-head', agentId])
+  expect(r.exitCode).toBe(0)
+  expect(r.stdout).toContain('(no session yet)')
+})
+
+test('agent session-head --json emits the SessionHeadResponse shape', async () => {
+  let r = await server.cli(['profile', 'create', 'p', '--model', 'anthropic:claude-opus-4-6'])
+  expect(r.exitCode).toBe(0)
+
+  r = await server.cli(['agent', 'spawn', '--profile', 'p', '--name', 'A'])
+  expect(r.exitCode).toBe(0)
+  const agentId = extractAgentId(r.stdout)
+
+  r = await server.cli(['agent', 'session-head', agentId, '--json'])
+  expect(r.exitCode).toBe(0)
+  const body = JSON.parse(r.stdout) as { file: string | null; size: number }
+  expect(body).toEqual({ file: null, size: 0 })
+})
+
+test('agent session-head returns 404 for an unknown agent', async () => {
+  // Prefix matching needs at least 4 chars; use one that could not resolve.
+  const r = await server.cli(['agent', 'session-head', 'deadbeef-no-such-agent'])
+  expect(r.exitCode).not.toBe(0)
+  // ApiClientError prints "error: agent not found: …"
+  expect(r.stderr + r.stdout).toMatch(/not found/i)
+})

package/apps/cli/test/skill.test.ts

@@ -0,0 +1,128 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import AdmZip from 'adm-zip'
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest'
+import { extractAgentId } from './helpers.ts'
+import { startTestServer, type TestServer } from './server-fixture.ts'
+
+let server: TestServer
+beforeAll(async () => {
+  server = await startTestServer()
+})
+afterAll(() => server.stop())
+beforeEach(() => server.reset())
+
+function fixtureSkillsDir(skills: string[]): string {
+  const root = mkdtempSync(join(tmpdir(), 'bazilion-skill-fixture-'))
+  for (const name of skills) {
+    const dir = join(root, name)
+    mkdirSync(dir, { recursive: true })
+    writeFileSync(
+      join(dir, 'SKILL.md'),
+      `---
+name: ${name}
+description: Test skill ${name}.
+---
+
+body of ${name}
+`,
+    )
+  }
+  return root
+}
+
+test('skill list shows nothing when none installed', async () => {
+  const r = await server.cli(['skill', 'list'])
+  expect(r.exitCode).toBe(0)
+  expect(r.stdout).toContain('no skills installed')
+})
+
+test('skill import + list + rm round-trip', async () => {
+  const source = fixtureSkillsDir(['alpha', 'beta'])
+
+  let r = await server.cli(['skill', 'import', '--from', source])
+  expect(r.exitCode).toBe(0)
+  expect(r.stdout).toContain('imported alpha')
+  expect(r.stdout).toContain('imported beta')
+
+  r = await server.cli(['skill', 'list'])
+  expect(r.stdout).toContain('alpha')
+  expect(r.stdout).toContain('beta')
+  expect(r.stdout).toContain('Test skill')
+
+  r = await server.cli(['skill', 'rm', 'alpha'])
+  expect(r.exitCode).toBe(0)
+
+  r = await server.cli(['skill', 'list'])
+  expect(r.stdout).not.toContain('alpha')
+  expect(r.stdout).toContain('beta')
+})
+
+test('skill import skips existing without --force', async () => {
+  const source = fixtureSkillsDir(['dup'])
+  await server.cli(['skill', 'import', '--from', source])
+
+  const r = await server.cli(['skill', 'import', '--from', source])
+  expect(r.stdout).toContain('skipped dup')
+})
+
+test('skill import --from openclaw resolves to ~/.openclaw/skills', async () => {
+  // We don't assume the user actually has skills there. We just check that
+  // when ~/.openclaw/skills doesn't exist, the error message references the
+  // path that the server (not the client) would resolve.
+  const r = await server.cli(['skill', 'import', '--from', 'openclaw'])
+  if (r.exitCode !== 0) {
+    expect(r.stderr + r.stdout).toMatch(/\.openclaw/)
+  }
+})
+
+test('skill list --agent shows attached skills with descriptions', async () => {
+  const source = fixtureSkillsDir(['s1', 's2'])
+  await server.cli(['skill', 'import', '--from', source])
+
+  await server.cli(['profile', 'create', 'p', '--model', 'm', '--skills', 's1,s2'])
+  let r = await server.cli(['agent', 'spawn', '--profile', 'p'])
+  const id = extractAgentId(r.stdout)
+
+  r = await server.cli(['skill', 'list', '--agent', id])
+  expect(r.stdout).toContain('s1')
+  expect(r.stdout).toContain('s2')
+  expect(r.stdout).toContain('Test skill s1')
+})
+
+test('skill list --agent reports missing skills', async () => {
+  await server.cli(['profile', 'create', 'p', '--model', 'm', '--skills', 'ghost'])
+  let r = await server.cli(['agent', 'spawn', '--profile', 'p'])
+  const id = extractAgentId(r.stdout)
+
+  r = await server.cli(['skill', 'list', '--agent', id])
+  expect(r.stdout).toContain('missing: ghost')
+})
+
+function fixtureSkillsZip(skills: string[]): string {
+  const zip = new AdmZip()
+  for (const name of skills) {
+    zip.addFile(
+      `${name}/SKILL.md`,
+      Buffer.from(`---\nname: ${name}\ndescription: Test skill ${name}.\n---\n\nbody of ${name}\n`),
+    )
+  }
+  const dir = mkdtempSync(join(tmpdir(), 'bazilion-skill-zip-fixture-'))
+  const zipPath = join(dir, 'skills.zip')
+  zip.writeZip(zipPath)
+  return zipPath
+}
+
+test('skill import --from <local.zip> uploads via multipart and installs every skill', async () => {
+  const zipPath = fixtureSkillsZip(['zapha', 'zbeta'])
+
+  let r = await server.cli(['skill', 'import', '--from', zipPath])
+  expect(r.exitCode).toBe(0)
+  expect(r.stdout).toContain('imported zapha')
+  expect(r.stdout).toContain('imported zbeta')
+
+  r = await server.cli(['skill', 'list'])
+  expect(r.stdout).toContain('zapha')
+  expect(r.stdout).toContain('zbeta')
+})

package/apps/cli/test/token.test.ts

@@ -0,0 +1,109 @@
+import { readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest'
+import { startTestServer, type TestServer } from './server-fixture.ts'
+
+let server: TestServer
+
+beforeAll(async () => {
+  server = await startTestServer()
+})
+
+afterAll(async () => {
+  await server.stop()
+})
+beforeEach(() => server.reset())
+
+test('token show-local prints the bootstrap token from auth.json', async () => {
+  const raw = readFileSync(join(server.home, 'auth.json'), 'utf8')
+  const expected = JSON.parse(raw).token as string
+  expect(typeof expected).toBe('string')
+
+  const res = await server.cli(['token', 'show-local'])
+  expect(res.exitCode).toBe(0)
+  expect(res.stdout.trim()).toBe(expected)
+})
+
+test('token create mints a token and prints the plaintext exactly once', async () => {
+  const res = await server.cli(['token', 'create', 'laptop'])
+  expect(res.exitCode).toBe(0)
+  expect(res.stdout).toMatch(/label: laptop/)
+  expect(res.stdout).toMatch(/token: [0-9a-f]{48}/)
+  expect(res.stdout).toMatch(/id: /)
+})
+
+test('token list shows active tokens and hides revoked by default', async () => {
+  const createA = await server.cli(['token', 'create', 'alpha'])
+  const idA = createA.stdout.match(/id:\s+([\w-]+)/)?.[1] as string
+  await server.cli(['token', 'create', 'beta'])
+  const revoke = await server.cli(['token', 'revoke', idA])
+  expect(revoke.exitCode).toBe(0)
+
+  const activeList = await server.cli(['token', 'list'])
+  expect(activeList.stdout).not.toContain(idA)
+  expect(activeList.stdout).toContain('beta')
+
+  const allList = await server.cli(['token', 'list', '--all'])
+  expect(allList.stdout).toContain(idA)
+  expect(allList.stdout).toContain('revoked')
+})
+
+test('a minted token authenticates subsequent API calls', async () => {
+  const create = await server.cli(['token', 'create', 'laptop'])
+  const token = create.stdout.match(/token:\s+([0-9a-f]+)/)?.[1] as string
+  expect(token).toBeTruthy()
+
+  const res = await fetch(`${server.url}/api/profiles`, {
+    headers: { cookie: `bz_token=${token}` },
+  })
+  expect(res.status).toBe(200)
+})
+
+test('revoked tokens are rejected', async () => {
+  const create = await server.cli(['token', 'create', 'burn'])
+  const token = create.stdout.match(/token:\s+([0-9a-f]+)/)?.[1] as string
+  const id = create.stdout.match(/id:\s+([\w-]+)/)?.[1] as string
+  await server.cli(['token', 'revoke', id])
+
+  const res = await fetch(`${server.url}/api/profiles`, {
+    headers: { cookie: `bz_token=${token}` },
+  })
+  expect(res.status).toBe(401)
+})
+
+test('login --server --token verifies and writes remote to auth.json', async () => {
+  const create = await server.cli(['token', 'create', 'remote'])
+  const token = create.stdout.match(/token:\s+([0-9a-f]+)/)?.[1] as string
+
+  // login runs against `server.home` — bypass the env-var short-circuit by
+  // not setting BAZILION_SERVER/TOKEN for this specific invocation.
+  const login = await server.cli(['login', '--server', server.url, '--token', token], {
+    BAZILION_SERVER: '',
+    BAZILION_TOKEN: '',
+  })
+  expect(login.exitCode).toBe(0)
+  expect(login.stdout).toMatch(/saved remote/)
+
+  const configPath = join(server.home, 'auth.json')
+  const config = JSON.parse(readFileSync(configPath, 'utf8')) as {
+    remote?: { server: string; token: string }
+  }
+  expect(config.remote?.server).toBe(server.url)
+  expect(config.remote?.token).toBe(token)
+})
+
+test('login --clear removes the stored remote', async () => {
+  const configPath = join(server.home, 'auth.json')
+  const existing = JSON.parse(readFileSync(configPath, 'utf8')) as Record<string, unknown>
+  existing.remote = { server: 'http://example.invalid', token: 'abc' }
+  writeFileSync(configPath, `${JSON.stringify(existing, null, 2)}\n`)
+
+  const clear = await server.cli(
+    ['login', '--server', 'http://example.invalid', '--token', 'x', '--clear'],
+    { BAZILION_SERVER: '', BAZILION_TOKEN: '' },
+  )
+  expect(clear.exitCode).toBe(0)
+
+  const after = JSON.parse(readFileSync(configPath, 'utf8')) as { remote?: unknown }
+  expect(after.remote).toBeUndefined()
+})