Merge pull request #2284 from netease-youdao/fisherdaddy/chore-settings-and-cowork-cleanup

chore: settings and cowork cleanup

Author: fisherdaddy

src/main/libs/openclawCronLegacyMigration.test.ts

@@ -157,4 +157,95 @@ describe('openclawCronLegacyMigration', () => {
 
     expect(result).toEqual({ status: 'failed', code: 2 });
   });
+
+  test('archives legacy cron files after successful doctor run', async () => {
+    const storePath = resolveLegacyCronStorePath(stateDir);
+    const statePath = path.join(stateDir, 'cron', 'jobs-state.json');
+    const runLogPath = path.join(stateDir, 'cron', 'runs', 'job-1.jsonl');
+    writeFile(storePath, '{"version":1,"jobs":[{"id":"job-1"}]}\n');
+    writeFile(statePath, '{"job-1":{}}\n');
+    writeFile(runLogPath, '{"status":"ok"}\n');
+    const runner = vi.fn<LegacyCronMigrationRunner>().mockResolvedValue({
+      code: 0,
+      stdout: '',
+      stderr: '',
+    });
+
+    const result = await migrateLegacyCronStorageWithDoctor({
+      stateDir,
+      runtimeRoot,
+      electronNodeRuntimePath,
+      env: {},
+      runner,
+    });
+
+    expect(result).toEqual({ status: 'migrated', code: 0 });
+    expect(fs.existsSync(storePath)).toBe(false);
+    expect(fs.existsSync(statePath)).toBe(false);
+    expect(fs.existsSync(runLogPath)).toBe(false);
+    expect(fs.readFileSync(`${storePath}.migrated`, 'utf8')).toBe('{"version":1,"jobs":[{"id":"job-1"}]}\n');
+    expect(fs.readFileSync(`${statePath}.migrated`, 'utf8')).toBe('{"job-1":{}}\n');
+    expect(fs.readFileSync(`${runLogPath}.migrated`, 'utf8')).toBe('{"status":"ok"}\n');
+    expect(hasLegacyCronStorage(stateDir)).toBe(false);
+
+    const rerun = await migrateLegacyCronStorageWithDoctor({
+      stateDir,
+      runtimeRoot,
+      electronNodeRuntimePath,
+      env: {},
+      runner,
+    });
+
+    expect(rerun).toEqual({ status: 'skipped', reason: 'no-legacy-cron-files' });
+    expect(runner).toHaveBeenCalledTimes(1);
+  });
+
+  test('keeps legacy cron files when doctor fails', async () => {
+    const storePath = resolveLegacyCronStorePath(stateDir);
+    writeFile(storePath, '{"version":1,"jobs":[]}\n');
+    const runner = vi.fn<LegacyCronMigrationRunner>().mockResolvedValue({
+      code: 2,
+      stdout: '',
+      stderr: 'failed',
+    });
+
+    await migrateLegacyCronStorageWithDoctor({
+      stateDir,
+      runtimeRoot,
+      electronNodeRuntimePath,
+      env: {},
+      runner,
+    });
+
+    expect(fs.existsSync(storePath)).toBe(true);
+    expect(hasLegacyCronStorage(stateDir)).toBe(true);
+  });
+
+  test('does not clobber an existing archive from a previous migration', async () => {
+    const storePath = resolveLegacyCronStorePath(stateDir);
+    writeFile(`${storePath}.migrated`, 'earlier archive\n');
+    writeFile(storePath, '{"version":1,"jobs":[{"id":"job-2"}]}\n');
+    const runner = vi.fn<LegacyCronMigrationRunner>().mockResolvedValue({
+      code: 0,
+      stdout: '',
+      stderr: '',
+    });
+
+    const result = await migrateLegacyCronStorageWithDoctor({
+      stateDir,
+      runtimeRoot,
+      electronNodeRuntimePath,
+      env: {},
+      runner,
+    });
+
+    expect(result).toEqual({ status: 'migrated', code: 0 });
+    expect(fs.existsSync(storePath)).toBe(false);
+    expect(fs.readFileSync(`${storePath}.migrated`, 'utf8')).toBe('earlier archive\n');
+    const fallbackArchives = fs.readdirSync(path.join(stateDir, 'cron'))
+      .filter((name) => name.startsWith('jobs.json.migrated-'));
+    expect(fallbackArchives).toHaveLength(1);
+    expect(fs.readFileSync(path.join(stateDir, 'cron', fallbackArchives[0]), 'utf8'))
+      .toBe('{"version":1,"jobs":[{"id":"job-2"}]}\n');
+  });
 });

src/main/libs/openclawCronLegacyMigration.ts

@@ -34,16 +34,21 @@ function resolveLegacyCronStatePath(stateDir: string): string {
   return path.join(stateDir, 'cron', 'jobs-state.json');
 }
 
-function legacyCronRunLogsExist(stateDir: string): boolean {
+function listLegacyCronRunLogPaths(stateDir: string): string[] {
   const runsDir = path.join(stateDir, 'cron', 'runs');
   try {
     return fs.readdirSync(runsDir, { withFileTypes: true })
-      .some((entry) => entry.isFile() && entry.name.endsWith('.jsonl'));
+      .filter((entry) => entry.isFile() && entry.name.endsWith('.jsonl'))
+      .map((entry) => path.join(runsDir, entry.name));
   } catch {
-    return false;
+    return [];
   }
 }
 
+function legacyCronRunLogsExist(stateDir: string): boolean {
+  return listLegacyCronRunLogPaths(stateDir).length > 0;
+}
+
 export function hasLegacyCronStorage(stateDir: string): boolean {
   return (
     fs.existsSync(resolveLegacyCronStorePath(stateDir)) ||
@@ -52,6 +57,43 @@ export function hasLegacyCronStorage(stateDir: string): boolean {
   );
 }
 
+const LEGACY_CRON_ARCHIVE_SUFFIX = '.migrated';
+
+function resolveLegacyCronArchivePath(filePath: string): string {
+  const preferred = `${filePath}${LEGACY_CRON_ARCHIVE_SUFFIX}`;
+  if (!fs.existsSync(preferred)) {
+    return preferred;
+  }
+  return `${preferred}-${Date.now()}`;
+}
+
+// The pinned OpenClaw runtime keeps cron jobs in its shared SQLite state
+// (the configured cron.store path only acts as the store key); the legacy
+// JSON/JSONL files are read solely by the doctor migration. Rename them after
+// a successful doctor run so hasLegacyCronStorage() stops re-triggering the
+// doctor on every startup.
+export function archiveLegacyCronStorage(stateDir: string): string[] {
+  const candidates = [
+    resolveLegacyCronStorePath(stateDir),
+    resolveLegacyCronStatePath(stateDir),
+    ...listLegacyCronRunLogPaths(stateDir),
+  ];
+  const archived: string[] = [];
+  for (const filePath of candidates) {
+    try {
+      if (!fs.existsSync(filePath)) {
+        continue;
+      }
+      const archivePath = resolveLegacyCronArchivePath(filePath);
+      fs.renameSync(filePath, archivePath);
+      archived.push(archivePath);
+    } catch (error) {
+      console.warn(`[OpenClaw] Failed to archive legacy cron file: ${filePath}`, error);
+    }
+  }
+  return archived;
+}
+
 function tailLog(text: string): string {
   if (text.length <= LOG_TAIL_LIMIT) {
     return text;
@@ -159,7 +201,15 @@ export async function migrateLegacyCronStorageWithDoctor(params: {
     });
 
     if (result.code === 0) {
-      console.log('[OpenClaw] Legacy cron doctor migration completed.');
+      const archived = archiveLegacyCronStorage(params.stateDir);
+      if (archived.length > 0) {
+        console.log(
+          '[OpenClaw] Legacy cron doctor migration completed; archived: '
+          + archived.map((filePath) => path.basename(filePath)).join(', '),
+        );
+      } else {
+        console.log('[OpenClaw] Legacy cron doctor migration completed.');
+      }
       return { status: 'migrated', code: result.code };
     }
 

src/main/libs/pythonRuntime.ts

@@ -325,6 +325,7 @@ function runPythonCommand(
     stdio: 'pipe',
     timeout: 60_000,
     env,
+    windowsHide: true,
   });
   if (result.status === 0) {
     return { ok: true };

src/renderer/components/Settings.tsx

@@ -72,7 +72,7 @@ import {
   shouldUseMaxCompletionTokensForOpenAI,
   shouldUseOpenAIResponsesForProvider,
 } from './settings/modelProviderUtils';
-import ModelSettingsSection, { ModelEditorDialog } from './settings/ModelSettingsSection';
+import ModelSettingsSection, { DeleteProviderConfirmDialog, ModelEditorDialog } from './settings/ModelSettingsSection';
 import EmailSkillConfig from './skills/EmailSkillConfig';
 import ThemedSelect from './ui/ThemedSelect';
 
@@ -5167,8 +5167,6 @@ const Settings: React.FC<SettingsProps> = ({
             testResult={testResult}
             isTestResultModalOpen={isTestResultModalOpen}
             setIsTestResultModalOpen={setIsTestResultModalOpen}
-            pendingDeleteProvider={pendingDeleteProvider}
-            setPendingDeleteProvider={setPendingDeleteProvider}
             importInputRef={importInputRef}
             handleImportProvidersClick={handleImportProvidersClick}
             handleExportProviders={handleExportProviders}
@@ -5177,7 +5175,6 @@ const Settings: React.FC<SettingsProps> = ({
             toggleProviderEnabled={toggleProviderEnabled}
             handleAddCustomProvider={handleAddCustomProvider}
             handleDeleteCustomProvider={handleDeleteCustomProvider}
-            confirmDeleteCustomProvider={confirmDeleteCustomProvider}
             handleProviderConfigChange={handleProviderConfigChange}
             setProviders={setProviders}
             handleMiniMaxDeviceLogin={handleMiniMaxDeviceLogin}
@@ -5583,6 +5580,13 @@ const Settings: React.FC<SettingsProps> = ({
           handleModelDialogKeyDown={handleModelDialogKeyDown}
         />
 
+        <DeleteProviderConfirmDialog
+          pendingDeleteProvider={pendingDeleteProvider}
+          providers={providers}
+          onCancel={() => setPendingDeleteProvider(null)}
+          onConfirm={confirmDeleteCustomProvider}
+        />
+
           {showOpenClawRepairConfirm && (
             <div
               className="absolute inset-0 z-30 flex items-center justify-center bg-black/35 px-4 rounded-2xl"

src/renderer/components/cowork/CoworkView.tsx

@@ -38,7 +38,6 @@ import { useAgentSelectedModel } from './agentModelSelection';
 import { CoworkUiEvent } from './constants';
 import CoworkPromptInput, { type CoworkPromptInputRef } from './CoworkPromptInput';
 import CoworkSessionDetail from './CoworkSessionDetail';
-import HomeRecentTasks from './HomeRecentTasks';
 import { reportPromptTemplateAction } from './promptAnalytics';
 import { buildCoworkContinuationSystemPrompt, buildCoworkSystemPrompt } from './skillSystemPrompt';
 
@@ -858,8 +857,6 @@ const CoworkView: React.FC<CoworkViewProps> = ({ onRequestAppSettings, onShowSki
             <CreditsResetCampaignFloat />
           </div>
 
-          {/* Recent tasks - one-click resume for returning users */}
-          <HomeRecentTasks />
           <div aria-hidden="true" className="w-full min-h-[24px] flex-[3_0_0px]" />
         </div>
       </div>