test(cli): expand clawdbot sync coverage

Author: steipete

e2e/clawdhub.e2e.test.ts

@@ -174,6 +174,61 @@ describe('clawdhub e2e', () => {
     }
   })
 
+  it('sync dry-run finds skills from clawdbot.json roots', async () => {
+    const registry = process.env.CLAWDHUB_REGISTRY?.trim() || 'https://clawdhub.com'
+    const site = process.env.CLAWDHUB_SITE?.trim() || 'https://clawdhub.com'
+    const token = mustGetToken() ?? (await readGlobalConfig())?.token ?? null
+    if (!token) {
+      throw new Error('Missing token. Set CLAWDHUB_E2E_TOKEN or run: bun clawdhub auth login')
+    }
+
+    const cfg = await makeTempConfig(registry, token)
+    const root = await mkdtemp(join(tmpdir(), 'clawdhub-e2e-clawdbot-'))
+    const stateDir = join(root, 'state')
+    const configPath = join(root, 'clawdbot.json')
+    const workspace = join(root, 'clawd-work')
+    const skillsRoot = join(workspace, 'skills')
+    const skillDir = join(skillsRoot, 'auto-skill')
+
+    try {
+      await mkdir(skillDir, { recursive: true })
+      await writeFile(join(skillDir, 'SKILL.md'), '# Skill\n', 'utf8')
+
+      const config = `{
+        // JSON5-style comments + trailing commas
+        routing: {
+          agents: {
+            work: { name: 'Work', workspace: '${workspace}', },
+          },
+        },
+      }`
+      await writeFile(configPath, config, 'utf8')
+
+      const result = spawnSync(
+        'bun',
+        ['clawdhub', 'sync', '--dry-run', '--all', '--site', site, '--registry', registry],
+        {
+          cwd: process.cwd(),
+          env: {
+            ...process.env,
+            CLAWDHUB_CONFIG_PATH: cfg.path,
+            CLAWDHUB_DISABLE_TELEMETRY: '1',
+            CLAWDBOT_CONFIG_PATH: configPath,
+            CLAWDBOT_STATE_DIR: stateDir,
+          },
+          encoding: 'utf8',
+        },
+      )
+      expect(result.status).toBe(0)
+      expect(result.stderr).not.toMatch(/error:/i)
+      expect(result.stdout).toMatch(/Dry run/i)
+      expect(result.stdout).toMatch(/auto-skill/i)
+    } finally {
+      await rm(root, { recursive: true, force: true })
+      await rm(cfg.dir, { recursive: true, force: true })
+    }
+  })
+
   it('publishes, deletes, and undeletes a skill (logged-in)', async () => {
     const registry = process.env.CLAWDHUB_REGISTRY?.trim() || 'https://clawdhub.com'
     const site = process.env.CLAWDHUB_SITE?.trim() || 'https://clawdhub.com'

packages/clawdhub/src/cli/clawdbotConfig.test.ts

@@ -1,5 +1,5 @@
 /* @vitest-environment node */
-import { mkdtemp, writeFile } from 'node:fs/promises'
+import { mkdir, mkdtemp, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join, resolve } from 'node:path'
 import { afterEach, describe, expect, it } from 'vitest'
@@ -56,4 +56,46 @@ describe('resolveClawdbotSkillRoots', () => {
     expect(labels[resolve(home, 'shared', 'skills')]).toBe('Extra: skills')
     expect(labels[resolve('/opt/skills')]).toBe('Extra: skills')
   })
+
+  it('respects CLAWDBOT_STATE_DIR and CLAWDBOT_CONFIG_PATH overrides', async () => {
+    const base = await mkdtemp(join(tmpdir(), 'clawdhub-clawdbot-override-'))
+    const home = join(base, 'home')
+    const stateDir = join(base, 'custom-state')
+    const configPath = join(base, 'config', 'clawdbot.json')
+
+    process.env.HOME = home
+    process.env.CLAWDBOT_STATE_DIR = stateDir
+    process.env.CLAWDBOT_CONFIG_PATH = configPath
+
+    const config = `{
+      agent: { workspace: "${join(base, 'workspace-main')}" },
+    }`
+    await mkdir(join(base, 'config'), { recursive: true })
+    await writeFile(configPath, config, 'utf8')
+
+    const { roots, labels } = await resolveClawdbotSkillRoots()
+
+    expect(roots).toEqual(
+      expect.arrayContaining([
+        resolve(stateDir, 'skills'),
+        resolve(join(base, 'workspace-main'), 'skills'),
+      ]),
+    )
+    expect(labels[resolve(stateDir, 'skills')]).toBe('Shared skills')
+    expect(labels[resolve(join(base, 'workspace-main'), 'skills')]).toBe('Agent: main')
+  })
+
+  it('returns shared skills root when config is missing', async () => {
+    const base = await mkdtemp(join(tmpdir(), 'clawdhub-clawdbot-missing-'))
+    const stateDir = join(base, 'state')
+    const configPath = join(base, 'missing', 'clawdbot.json')
+
+    process.env.CLAWDBOT_STATE_DIR = stateDir
+    process.env.CLAWDBOT_CONFIG_PATH = configPath
+
+    const { roots, labels } = await resolveClawdbotSkillRoots()
+
+    expect(roots).toEqual([resolve(stateDir, 'skills')])
+    expect(labels[resolve(stateDir, 'skills')]).toBe('Shared skills')
+  })
 })

packages/clawdhub/src/cli/commands/sync.test.ts

@@ -57,6 +57,11 @@ vi.mock('../scanSkills.js', () => ({
   getFallbackSkillRoots: vi.fn(() => []),
 }))
 
+const mockResolveClawdbotSkillRoots = vi.fn(async () => ({ roots: [], labels: {} }))
+vi.mock('../clawdbotConfig.js', () => ({
+  resolveClawdbotSkillRoots: () => mockResolveClawdbotSkillRoots(),
+}))
+
 vi.mock('../../skills.js', async () => {
   const actual = await vi.importActual<typeof import('../../skills.js')>('../../skills.js')
   return {
@@ -219,6 +224,35 @@ describe('cmdSync', () => {
     expect(output).toMatch(/dup-skill/)
   })
 
+  it('prints labeled roots when clawdbot roots are detected', async () => {
+    interactive = false
+    mockResolveClawdbotSkillRoots.mockResolvedValueOnce({
+      roots: ['/auto'],
+      labels: { '/auto': 'Agent: Work' },
+    })
+    const { findSkillFolders } = await import('../scanSkills.js')
+    vi.mocked(findSkillFolders).mockImplementation(async (root: string) => {
+      if (root === '/auto') {
+        return [{ folder: '/auto/alpha', slug: 'alpha', displayName: 'Alpha' }]
+      }
+      return []
+    })
+    mockApiRequest.mockImplementation(async (_registry: string, args: { path: string }) => {
+      if (args.path === '/api/v1/whoami') return { user: { handle: 'steipete' } }
+      if (args.path === '/api/cli/telemetry/sync') return { ok: true }
+      if (args.path.startsWith('/api/v1/resolve?')) {
+        throw new Error('Skill not found')
+      }
+      throw new Error(`Unexpected apiRequest: ${args.path}`)
+    })
+
+    await cmdSync(makeOpts(), { all: true, dryRun: true }, true)
+
+    const output = mockLog.mock.calls.map((call) => String(call[0])).join('\n')
+    expect(output).toMatch(/Roots with skills/)
+    expect(output).toMatch(/Agent: Work/)
+  })
+
   it('allows empty changelog for updates (interactive)', async () => {
     interactive = true
     mockApiRequest.mockImplementation(async (_registry: string, args: { path: string }) => {

packages/clawdhub/src/cli/commands/syncHelpers.test.ts

@@ -0,0 +1,26 @@
+/* @vitest-environment node */
+import { describe, expect, it, vi } from 'vitest'
+
+vi.mock('../scanSkills.js', () => ({
+  findSkillFolders: vi.fn(async (root: string) => {
+    if (root.endsWith('/with-skill')) {
+      return [{ folder: `${root}/demo`, slug: 'demo', displayName: 'Demo' }]
+    }
+    return []
+  }),
+}))
+
+const { scanRootsWithLabels } = await import('./syncHelpers.js')
+
+describe('scanRootsWithLabels', () => {
+  it('attaches labels to roots with skills', async () => {
+    const roots = ['/tmp/with-skill', '/tmp/empty', '/tmp/with-skill']
+    const labels = { '/tmp/with-skill': 'Agent: Work' }
+
+    const result = await scanRootsWithLabels(roots, labels)
+
+    expect(result.rootsWithSkills).toEqual(['/tmp/with-skill'])
+    expect(result.rootLabels).toEqual({ '/tmp/with-skill': 'Agent: Work' })
+    expect(result.skills.map((skill) => skill.slug)).toEqual(['demo'])
+  })
+})