@myclaw163/clawclaw-cli 0.6.74 → 0.6.76

package/src/lib/hub-install.ts

@@ -4,15 +4,21 @@ import { dirname, extname, join } from 'path';
 import { getWorkspaceDir } from './init-command.js';
 import type { ResourceType, ResourceDetail } from './hub-client.js';
 import { unzip } from './hub-unzip.js';
+import {
+  ensureUserDataLayout,
+  getUserDataDir,
+  getUserDataHubStrategyLockfile,
+  getUserDataStrategiesDir,
+} from './user-data.js';
 
 export interface InstalledEntry { type: ResourceType; id: string; title: string; path: string; installedAt: string; }
 export type Lockfile = Record<string, InstalledEntry>; // keyed by "<type>/<id>"
 
 export function hubDir(): string { return join(getWorkspaceDir(), 'hub'); }
 export function lockfilePath(): string { return join(hubDir(), 'installed.json'); }
+export function strategyLockfilePath(): string { return getUserDataHubStrategyLockfile(getWorkspaceDir()); }
 
-export function readLockfile(): Lockfile {
-  const p = lockfilePath();
+function readJsonLockfile(p: string): Lockfile {
   if (!existsSync(p)) return {};
   try {
     return JSON.parse(readFileSync(p, 'utf8')) as Lockfile;
@@ -22,11 +28,39 @@ export function readLockfile(): Lockfile {
   }
 }
 
-export function writeLockfile(lock: Lockfile): void {
+export function readSkillLockfile(): Lockfile {
+  return Object.fromEntries(
+    Object.entries(readJsonLockfile(lockfilePath())).filter(([, entry]) => entry.type === 'skill'),
+  );
+}
+
+export function readStrategyLockfile(): Lockfile {
+  ensureUserDataLayout(getWorkspaceDir());
+  return Object.fromEntries(
+    Object.entries(readJsonLockfile(strategyLockfilePath())).filter(([, entry]) => entry.type === 'strategy'),
+  );
+}
+
+export function readLockfile(): Lockfile {
+  return { ...readSkillLockfile(), ...readStrategyLockfile() };
+}
+
+function writeSkillLockfile(lock: Lockfile): void {
   mkdirSync(hubDir(), { recursive: true });
   writeFileSync(lockfilePath(), JSON.stringify(lock, null, 2) + '\n', 'utf8');
 }
 
+function writeStrategyLockfile(lock: Lockfile): void {
+  const p = strategyLockfilePath();
+  mkdirSync(dirname(p), { recursive: true });
+  writeFileSync(p, JSON.stringify(lock, null, 2) + '\n', 'utf8');
+}
+
+export function writeLockfile(lock: Lockfile): void {
+  writeSkillLockfile(Object.fromEntries(Object.entries(lock).filter(([, entry]) => entry.type === 'skill')));
+  writeStrategyLockfile(Object.fromEntries(Object.entries(lock).filter(([, entry]) => entry.type === 'strategy')));
+}
+
 function assertSafeSegment(label: string, s: string): void {
   if (!s || s === '.' || s === '..' || /[\\/:\0]/.test(s)) {
     throw new Error(`unsafe ${label} segment: '${s}'`);
@@ -39,7 +73,7 @@ export function slugify(title: string): string {
 
 const STRATEGY_EXTS = new Set(['.ts', '.tsx', '.js']);
 
-/** Workspace-relative install path, decided by resource type. */
+/** Install path relative to user-data for strategies and workspace for skills. */
 export function placementRelPath(detail: { type: ResourceType; id: string; title: string; fileName?: string }): string {
   assertSafeSegment('id', detail.id);
   if (detail.type === 'strategy') {
@@ -60,31 +94,31 @@ export interface InstallResult { ref: string; type: ResourceType; id: string; ti
 
 export function installResource(detail: ResourceDetail, artifact: Buffer, opts: { force?: boolean } = {}): InstallResult {
   const ws = getWorkspaceDir();
+  ensureUserDataLayout(ws);
   const ref = makeRef(detail.type, detail.id);
   const relPath = placementRelPath(detail);
-  const absPath = join(ws, relPath);
-  const lock = readLockfile();
+  const rootDir = detail.type === 'strategy' ? getUserDataDir(ws) : ws;
+  const absPath = join(rootDir, relPath);
+  const lock = detail.type === 'strategy' ? readStrategyLockfile() : readSkillLockfile();
   const tracked = lock[ref] !== undefined;
 
   if (detail.type === 'strategy') {
     if (existsSync(absPath) && !tracked && !opts.force) {
       throw new Error(`${relPath} already exists and is not tracked by hub; re-run with --force to overwrite`);
     }
-    mkdirSync(join(ws, 'strategies'), { recursive: true });
+    mkdirSync(getUserDataStrategiesDir(ws), { recursive: true });
     writeFileSync(absPath, artifact);
   } else {
     if (existsSync(absPath) && !tracked && !opts.force) {
       throw new Error(`skills/${slugify(detail.title) || detail.id} already exists and is not tracked by hub; re-run with --force to overwrite`);
     }
     const entries = unzip(artifact);
-    // Validate ALL entry paths before any filesystem mutation (no partial/unsafe writes).
     for (const e of entries) {
       if (e.path.includes('..') || e.path.startsWith('/') || /^[A-Za-z]:/.test(e.path)) {
         throw new Error(`unsafe path in skill archive: ${e.path}`);
       }
     }
-    // NOTE (v1): non-atomic — entries are decoded+validated in memory above, but a disk
-    // error mid-write could leave a partial skill dir. Acceptable for v1.
+    // Non-atomic by design: entries are decoded and validated before writing.
     if (existsSync(absPath)) rmSync(absPath, { recursive: true, force: true });
     mkdirSync(absPath, { recursive: true });
     for (const e of entries) {
@@ -101,18 +135,23 @@ export function installResource(detail: ResourceDetail, artifact: Buffer, opts:
     path: relPath.split('\\').join('/'),
     installedAt: new Date().toISOString(),
   };
-  writeLockfile(lock);
+  if (detail.type === 'strategy') writeStrategyLockfile(lock);
+  else writeSkillLockfile(lock);
   return { ref, type: detail.type, id: detail.id, title: detail.title, installedPath: absPath };
 }
 
 export function uninstallResource(ref: string): { removed: boolean; path?: string } {
-  const lock = readLockfile();
+  const type = ref.split('/')[0] as ResourceType;
+  const lock = type === 'strategy' ? readStrategyLockfile() : readSkillLockfile();
   const entry = lock[ref];
   if (!entry) return { removed: false };
-  const abs = join(getWorkspaceDir(), entry.path);
+  const ws = getWorkspaceDir();
+  const rootDir = type === 'strategy' ? getUserDataDir(ws) : ws;
+  const abs = join(rootDir, entry.path);
   if (existsSync(abs)) rmSync(abs, { recursive: true, force: true });
   delete lock[ref];
-  writeLockfile(lock);
+  if (type === 'strategy') writeStrategyLockfile(lock);
+  else writeSkillLockfile(lock);
   return { removed: true, path: abs };
 }
 

package/src/lib/hub-reminder.ts

@@ -7,19 +7,22 @@ import { join } from 'path';
 import { getWorkspaceDir, getProfileStateDir } from './init-command.js';
 import { listInstalled } from './hub-install.js';
 import { AuthStore } from './auth.js';
+import { ensureUserDataLayout, getUserDataStrategiesDir } from './user-data.js';
 
 export const HUB_URL = 'https://myclaw.163.com/hub';
 
 /**
  * True when this account has only ever run built-in default strategies: no
- * hub-installed strategy and no user strategy file in `<workspace>/strategies`.
+ * hub-installed strategy and no user strategy file in `<workspace>/user-data/strategies`.
  */
 export function usesOnlyBuiltinStrategies(): boolean {
   try {
     if (listInstalled().some((e) => e.type === 'strategy')) return false;
   } catch {}
   try {
-    const dir = join(getWorkspaceDir(), 'strategies');
+    const workspaceDir = getWorkspaceDir();
+    ensureUserDataLayout(workspaceDir);
+    const dir = getUserDataStrategiesDir(workspaceDir);
     if (existsSync(dir)) {
       const hasUserStrategy = readdirSync(dir).some((f) => {
         if (f.startsWith('_')) return false;

package/src/lib/init-command.ts

@@ -2,6 +2,13 @@ import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { isAbsolute, join, resolve, win32 } from 'path';
 import { homedir } from 'os';
 import type { AuthProfile } from './auth.js';
+import {
+  ensureUserDataLayout,
+  getRuntimeDir,
+  getUserDataAccountDir,
+  getUserDataMemoryFile,
+  getUserDataPersonaFile,
+} from './user-data.js';
 
 const ACCOUNT_DIRS = ['state', 'logs', 'games'];
 
@@ -52,6 +59,7 @@ export function cmdInit(force = false): { created: boolean; path: string } {
 
   mkdirSync(workspaceDir, { recursive: true });
   mkdirSync(join(workspaceDir, 'accounts'), { recursive: true });
+  ensureUserDataLayout(workspaceDir);
 
   if (!alreadyExists) {
     writeFileSync(
@@ -80,6 +88,8 @@ export function getAccountId(profile: Pick<AuthProfile, 'apiKey'>): string {
 
 export function createProfileDirs(profile: Pick<AuthProfile, 'apiKey'>): void {
   createAccountDirs(getAccountId(profile));
+  mkdirSync(getUserDataAccountDir(getWorkspaceDir(), profile), { recursive: true });
+  mkdirSync(getRuntimeDir(getWorkspaceDir()), { recursive: true });
 }
 
 export function getStateDir(accountId: string): string {
@@ -111,10 +121,10 @@ export function getProfileGamesDir(profile: Pick<AuthProfile, 'apiKey'>): string
 
 export function getProfileMemoryFile(profile: Pick<AuthProfile, 'apiKey'>): string {
   createProfileDirs(profile);
-  return join(getAccountDir(getAccountId(profile)), 'memory.md');
+  return getUserDataMemoryFile(getWorkspaceDir(), profile);
 }
 
 export function getProfilePersonaFile(profile: Pick<AuthProfile, 'apiKey'>): string {
   createProfileDirs(profile);
-  return join(getAccountDir(getAccountId(profile)), 'persona.md');
+  return getUserDataPersonaFile(getWorkspaceDir(), profile);
 }

package/src/lib/load-context.test.ts

@@ -40,13 +40,13 @@ describe('loadContext', () => {
   });
 
   it('returns persona and memory snapshots for the active account', () => {
-    const store = new AuthStore(authFile);
+    const store = new AuthStore();
     const snapshot = loadContext(store);
     expect(snapshot.persona.content).toBe('voice');
     expect(snapshot.persona.exists).toBe(true);
     expect(snapshot.memory.content).toBe('notes');
     expect(snapshot.memory.exists).toBe(true);
-    expect(snapshot.persona.path).toContain('persona.md');
-    expect(snapshot.memory.path).toContain('memory.md');
+    expect(snapshot.persona.path.split('\\').join('/')).toContain('user-data/accounts/');
+    expect(snapshot.memory.path.split('\\').join('/')).toContain('user-data/accounts/');
   });
 });

package/src/lib/server-registry.ts

@@ -142,7 +142,7 @@ export class ServerRegistry {
     }
   }
 
-  /** Persist gameServerUrl to auth profile (best-effort). */
+  /** Persist gameServerUrl to runtime auth state (best-effort). */
   private persistGameServerUrl(): void {
     if (!this.agentName) return;
     try {

package/src/lib/strategy-export.test.ts

@@ -30,6 +30,14 @@ describe('strategy-export', () => {
     rmSync(testWorkspace, { recursive: true, force: true });
   });
 
+  function userStrategiesDir(): string {
+    return join(testWorkspace, 'user-data', 'strategies');
+  }
+
+  function officialManifestFile(): string {
+    return join(testWorkspace, 'runtime', 'official-strategies', 'manifest.json');
+  }
+
   describe('rewriteBuiltinImports', () => {
     it('should rewrite ALL relative imports to @myclaw163/clawclaw-cli', () => {
       const source = `
@@ -75,7 +83,7 @@ export const strategy = { id: 'test', description: 'test', create: () => ({ name
     it('should export a formerly goal-based strategy with its knowledge sidecar', async () => {
       await exportStrategy('kill-lone');
 
-      const strategiesDir = join(testWorkspace, 'strategies');
+      const strategiesDir = userStrategiesDir();
       expect(existsSync(join(strategiesDir, 'kill-lone.ts'))).toBe(true);
       expect(existsSync(join(strategiesDir, 'kill-lone.knowledge.md'))).toBe(true);
     });
@@ -83,8 +91,8 @@ export const strategy = { id: 'test', description: 'test', create: () => ({ name
     it('should export a valid strategy', async () => {
       await exportStrategy('task-only');
 
-      const strategyFile = join(testWorkspace, 'strategies', 'task-only.ts');
-      const manifestFile = join(testWorkspace, 'strategies', '.official', 'manifest.json');
+      const strategyFile = join(userStrategiesDir(), 'task-only.ts');
+      const manifestFile = officialManifestFile();
 
       expect(existsSync(strategyFile)).toBe(true);
       expect(existsSync(manifestFile)).toBe(true);
@@ -130,7 +138,7 @@ export const strategy = {
     });
 
     it('should refuse to overwrite untracked files without --force', async () => {
-      const strategiesDir = join(testWorkspace, 'strategies');
+      const strategiesDir = userStrategiesDir();
       mkdirSync(strategiesDir, { recursive: true });
       writeFileSync(join(strategiesDir, 'task-only.ts'), '// user file', 'utf8');
 
@@ -141,7 +149,7 @@ export const strategy = {
     });
 
     it('should overwrite untracked files with --force', async () => {
-      const strategiesDir = join(testWorkspace, 'strategies');
+      const strategiesDir = userStrategiesDir();
       mkdirSync(strategiesDir, { recursive: true });
       writeFileSync(join(strategiesDir, 'task-only.ts'), '// user file', 'utf8');
 
@@ -155,7 +163,7 @@ export const strategy = {
       // First export
       await exportStrategy('task-only');
 
-      const strategiesDir = join(testWorkspace, 'strategies');
+      const strategiesDir = userStrategiesDir();
       const strategyFile = join(strategiesDir, 'task-only.ts');
 
       // Modify the file
@@ -189,7 +197,7 @@ export const strategy = {
       await exportStrategy('task-only');
 
       // Manually modify the manifest to simulate a stale hash
-      const manifestFile = join(testWorkspace, 'strategies', '.official', 'manifest.json');
+      const manifestFile = officialManifestFile();
       const manifest = JSON.parse(readFileSync(manifestFile, 'utf8'));
       manifest['task-only'].sourceHash = 'stale-hash-value';
       writeFileSync(manifestFile, JSON.stringify(manifest, null, 2), 'utf8');
@@ -202,7 +210,7 @@ export const strategy = {
       await exportStrategy('kill-lone');
 
       // Make both stale
-      const manifestFile = join(testWorkspace, 'strategies', '.official', 'manifest.json');
+      const manifestFile = officialManifestFile();
       const manifest = JSON.parse(readFileSync(manifestFile, 'utf8'));
       manifest['task-only'].sourceHash = 'stale-1';
       manifest['kill-lone'].sourceHash = 'stale-2';
@@ -218,7 +226,7 @@ export const strategy = {
       await exportStrategy('kill-lone');
 
       // Verify kill-lone has a sidecar hash (it has a .knowledge.md)
-      const manifestFile = join(testWorkspace, 'strategies', '.official', 'manifest.json');
+      const manifestFile = officialManifestFile();
       const manifest = JSON.parse(readFileSync(manifestFile, 'utf8'));
       expect(manifest['kill-lone'].sidecarHash).toBeDefined();
 

package/src/lib/strategy-export.ts

@@ -6,12 +6,15 @@ import { tmpdir } from 'os';
 import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
 import { getWorkspaceDir } from './init-command.js';
+import {
+  ensureUserDataLayout,
+  getRuntimeOfficialStrategiesDir,
+  getRuntimeOfficialStrategiesManifestFile,
+  getUserDataStrategiesDir,
+} from './user-data.js';
 import { importUserFile } from '../strategies/loader.js';
 
 // ── Constants ──────────────────────────────────────────────────────
-const OFFICIAL_DIR = '.official';
-const MANIFEST_FILE = 'manifest.json';
-
 // ── Types ──────────────────────────────────────────────────────────
 export interface ManifestEntry {
   sourceHash: string;
@@ -22,15 +25,17 @@ export type Manifest = Record<string, ManifestEntry>;
 
 // ── Helpers ────────────────────────────────────────────────────────
 function strategiesDir(): string {
-  return join(getWorkspaceDir(), 'strategies');
+  const workspaceDir = getWorkspaceDir();
+  ensureUserDataLayout(workspaceDir);
+  return getUserDataStrategiesDir(workspaceDir);
 }
 
 function officialDir(): string {
-  return join(strategiesDir(), OFFICIAL_DIR);
+  return getRuntimeOfficialStrategiesDir(getWorkspaceDir());
 }
 
 function manifestPath(): string {
-  return join(officialDir(), MANIFEST_FILE);
+  return getRuntimeOfficialStrategiesManifestFile(getWorkspaceDir());
 }
 
 export function readManifest(): Manifest {

package/src/lib/user-data.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import {
+  ensureUserDataLayout,
+  getRuntimeAuthStateFile,
+  getUserDataAccountHash,
+  getUserDataAuthFile,
+  getUserDataHubStrategyLockfile,
+  getUserDataMemoryFile,
+  getUserDataPersonaFile,
+  getUserDataStrategiesDir,
+} from './user-data.js';
+
+describe('user-data layout migration', () => {
+  let ws: string;
+
+  beforeEach(() => {
+    ws = mkdtempSync(join(tmpdir(), 'ccl-user-data-'));
+  });
+
+  afterEach(() => {
+    rmSync(ws, { recursive: true, force: true });
+  });
+
+  it('migrates only portable user data from the legacy workspace layout', () => {
+    const apiKey = 'claw_secret_123';
+    writeFileSync(join(ws, '.auth.json'), JSON.stringify({
+      activeProfile: 'lobster-1',
+      profiles: {
+        'lobster-1': {
+          agentName: 'lobster-1',
+          apiKey,
+          serverUrl: 'https://example.com/claw',
+          gameServerUrl: 'http://game.example.com',
+        },
+      },
+      neteaseTtsKey: 'tts-secret',
+    }, null, 2));
+
+    mkdirSync(join(ws, 'accounts', apiKey), { recursive: true });
+    writeFileSync(join(ws, 'accounts', apiKey, 'persona.md'), 'persona old', 'utf8');
+    writeFileSync(join(ws, 'accounts', apiKey, 'memory.md'), 'memory old', 'utf8');
+
+    mkdirSync(join(ws, 'strategies', '.official'), { recursive: true });
+    writeFileSync(join(ws, 'strategies', 'custom.ts'), 'export const strategy = {};', 'utf8');
+    writeFileSync(join(ws, 'strategies', '.official', 'manifest.json'), JSON.stringify({ 'task-only': { sourceHash: 'x' } }), 'utf8');
+
+    mkdirSync(join(ws, 'hub'), { recursive: true });
+    writeFileSync(join(ws, 'hub', 'installed.json'), JSON.stringify({
+      'strategy/abc': { type: 'strategy', id: 'abc', title: 'Strategy', path: 'strategies/custom.ts', installedAt: 'now' },
+      'skill/def': { type: 'skill', id: 'def', title: 'Skill', path: 'skills/helper', installedAt: 'now' },
+    }, null, 2), 'utf8');
+
+    ensureUserDataLayout(ws);
+
+    const auth = JSON.parse(readFileSync(getUserDataAuthFile(ws), 'utf8'));
+    expect(auth.activeProfile).toBe('lobster-1');
+    expect(auth.profiles['lobster-1'].apiKey).toBe(apiKey);
+    expect(auth.profiles['lobster-1'].gameServerUrl).toBeUndefined();
+    expect(auth.profiles['lobster-1'].tts.keys.leihuo).toBe('tts-secret');
+
+    const runtimeAuth = JSON.parse(readFileSync(getRuntimeAuthStateFile(ws), 'utf8'));
+    expect(runtimeAuth.profiles['lobster-1'].gameServerUrl).toBe('http://game.example.com');
+
+    expect(getUserDataAccountHash(apiKey)).toHaveLength(16);
+    expect(readFileSync(getUserDataPersonaFile(ws, { apiKey }), 'utf8')).toBe('persona old');
+    expect(readFileSync(getUserDataMemoryFile(ws, { apiKey }), 'utf8')).toBe('memory old');
+
+    expect(readFileSync(join(getUserDataStrategiesDir(ws), 'custom.ts'), 'utf8')).toContain('strategy');
+    expect(existsSync(join(getUserDataStrategiesDir(ws), '.official'))).toBe(false);
+
+    const strategyLock = JSON.parse(readFileSync(getUserDataHubStrategyLockfile(ws), 'utf8'));
+    expect(Object.keys(strategyLock)).toEqual(['strategy/abc']);
+    expect(strategyLock['skill/def']).toBeUndefined();
+  });
+
+  it('does not overwrite existing user-data account files', () => {
+    const apiKey = 'claw_keep_new';
+    writeFileSync(join(ws, '.auth.json'), JSON.stringify({
+      activeProfile: 'lobster-1',
+      profiles: {
+        'lobster-1': { agentName: 'lobster-1', apiKey, serverUrl: 'https://example.com/claw' },
+      },
+    }), 'utf8');
+    mkdirSync(join(ws, 'accounts', apiKey), { recursive: true });
+    writeFileSync(join(ws, 'accounts', apiKey, 'persona.md'), 'old persona', 'utf8');
+    mkdirSync(join(ws, 'user-data', 'accounts', getUserDataAccountHash(apiKey)), { recursive: true });
+    writeFileSync(getUserDataPersonaFile(ws, { apiKey }), 'new persona', 'utf8');
+
+    ensureUserDataLayout(ws);
+
+    expect(readFileSync(getUserDataPersonaFile(ws, { apiKey }), 'utf8')).toBe('new persona');
+  });
+});