bazilion 0.0.0 → 0.1.0

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

@@ -1,110 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,212 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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()
-})