@principles/pd-cli 1.101.0 → 1.103.0

package/tests/commands/console-launcher-edge-cases.test.ts

@@ -55,65 +55,32 @@ describe('Port competition scenarios', () => {
   });
 
   it('findAvailablePort skips occupied ports in sequence', async () => {
-    // Occupy 3 consecutive ports using dynamically allocated base port
-    const servers: net.Server[] = [];
-    // First, get a dynamic port to use as base
-    const probeServer = net.createServer();
-    const basePort = await new Promise<number>((resolve) => {
-      probeServer.listen(0, '127.0.0.1', () => {
-        const addr = probeServer.address();
-        if (typeof addr === 'object' && addr) resolve(addr.port);
-      });
-    });
-    await new Promise<void>((resolve) => probeServer.close(() => resolve()));
-
-    for (let i = 0; i < 3; i++) {
-      const s = net.createServer();
-      await new Promise<void>((resolve) => {
-        s.listen(basePort + i, '127.0.0.1', () => resolve());
-      });
-      servers.push(s);
-    }
-
+    // Use mock to simulate 3 consecutive occupied ports — avoids flaky real-network I/O
+    const basePort = 49200;
+    (globalThis as any).__mockIsPortInUse = async (_host: string, port: number) => {
+      return port >= basePort && port <= basePort + 2;
+    };
     try {
-      // Should skip all 3 and return the next free one
       const port = await findAvailablePort('127.0.0.1', basePort, 5);
+      // Should skip basePort, basePort+1, basePort+2 and return basePort+3
       expect(port).toBe(basePort + 3);
     } finally {
-      for (const s of servers) {
-        await new Promise<void>((resolve) => s.close(() => resolve()));
-      }
+      delete (globalThis as any).__mockIsPortInUse;
     }
   });
 
   it('returns null when all fallback ports are exhausted', async () => {
-    // Occupy a range of ports using dynamically allocated base port
-    const servers: net.Server[] = [];
-    const probeServer = net.createServer();
-    const basePort = await new Promise<number>((resolve) => {
-      probeServer.listen(0, '127.0.0.1', () => {
-        const addr = probeServer.address();
-        if (typeof addr === 'object' && addr) resolve(addr.port);
-      });
-    });
-    await new Promise<void>((resolve) => probeServer.close(() => resolve()));
-
-    for (let i = 0; i < 10; i++) {
-      const s = net.createServer();
-      await new Promise<void>((resolve) => {
-        s.listen(basePort + i, '127.0.0.1', () => resolve());
-      });
-      servers.push(s);
-    }
-
+    // Use mock to simulate all ports occupied — avoids flaky real-network I/O
+    const basePort = 49300;
+    (globalThis as any).__mockIsPortInUse = async (_host: string, port: number) => {
+      return port >= basePort && port <= basePort + 9;
+    };
     try {
-      // With limit=5, should return null after exhausting fallback
+      // With limit=5, all 5 candidates are occupied → null
       const port = await findAvailablePort('127.0.0.1', basePort, 5);
       expect(port).toBeNull();
     } finally {
-      for (const s of servers) {
-        await new Promise<void>((resolve) => s.close(() => resolve()));
-      }
+      delete (globalThis as any).__mockIsPortInUse;
     }
   });
 });

package/tests/commands/diagnose.test.ts

@@ -41,6 +41,23 @@ const { MockPrincipleTreeLedgerAdapter } = vi.hoisted(() => {
   return { MockPrincipleTreeLedgerAdapter };
 });
 
+const { mockResolveRuntimeFromPdConfig } = vi.hoisted(() => {
+  const mockResolveRuntimeFromPdConfig = vi.fn().mockReturnValue({
+    result: {
+      runtimeKind: 'pi-ai',
+      provider: 'test-provider',
+      model: 'test-model',
+      apiKeyEnv: 'TEST_KEY',
+      timeoutMs: 300000,
+      agentId: 'main',
+    },
+    legacyWarnings: [],
+    configSource: '.pd/config.yaml',
+    configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
+  });
+  return { mockResolveRuntimeFromPdConfig };
+});
+
 vi.mock('../../src/resolve-workspace.js', () => ({
   resolveWorkspaceDir: vi.fn().mockReturnValue('/tmp/fake-workspace'),
 }));
@@ -122,6 +139,10 @@ vi.mock('../../src/services/pd-config-loader.js', () => ({
   computeFlagsFromLoadResult: vi.fn().mockReturnValue({}),
 }));
 
+vi.mock('../../src/services/resolve-runtime-from-pd-config.js', () => ({
+  resolveRuntimeFromPdConfig: mockResolveRuntimeFromPdConfig,
+}));
+
 import { handleDiagnoseRun, handleDiagnoseStatus, type DiagnoseRunOptions } from '../../src/commands/diagnose.js';
 
 const SUCCEEDED_RESULT = {
@@ -177,14 +198,18 @@ describe('pd diagnose run --runtime routing', () => {
     exitSpy.mockRestore();
   });
 
-  it('HG-03: --runtime openclaw-cli without mode (no file config) fails via resolveRuntimeConfig', async () => {
-    mockResolveRuntimeConfig.mockReturnValueOnce({
-      ok: false,
-      reason: 'missing_openclaw_mode',
-      message: 'runtimeKind is openclaw-cli but no mode specified',
-      nextAction: 'Provide exactly one mode',
+  it('HG-03: --runtime openclaw-cli without mode (no file config) fails via resolveRuntimeFromPdConfig', async () => {
+    mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
+      result: {
+        ok: false,
+        reason: 'missing_openclaw_mode',
+        message: 'runtimeKind is openclaw-cli but no mode specified',
+        nextAction: 'Provide exactly one mode',
+      },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
     });
-    mockIsRuntimeConfigError.mockReturnValueOnce(true);
 
     const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
     const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
@@ -196,7 +221,7 @@ describe('pd diagnose run --runtime routing', () => {
       json: false,
     } as DiagnoseRunOptions);
 
-    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('no mode specified'));
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('no mode resolved'));
     expect(exitSpy).toHaveBeenCalledWith(1);
 
     consoleErrorSpy.mockRestore();
@@ -226,13 +251,17 @@ describe('pd diagnose run --runtime routing', () => {
   });
 
   it('DPB-09: openclaw-cli with file config openclawMode succeeds without CLI flag', async () => {
-    mockResolveRuntimeConfig.mockReturnValueOnce({
-      runtimeKind: 'openclaw-cli',
-      openclawMode: 'local',
-      timeoutMs: 300000,
-      agentId: 'main',
+    mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
+      result: {
+        runtimeKind: 'openclaw-cli',
+        openclawMode: 'local',
+        timeoutMs: 300000,
+        agentId: 'main',
+      },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
     });
-    mockIsRuntimeConfigError.mockReturnValueOnce(false);
 
     const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
     const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
@@ -250,14 +279,18 @@ describe('pd diagnose run --runtime routing', () => {
     exitSpy.mockRestore();
   });
 
-  it('DPB-09: openclaw-cli flag overrides file config mode', async () => {
-    mockResolveRuntimeConfig.mockReturnValueOnce({
-      runtimeKind: 'openclaw-cli',
-      openclawMode: 'gateway',
-      timeoutMs: 300000,
-      agentId: 'main',
+  it('DPB-09: openclaw-cli flag overrides file config mode (config=gateway, flag=local → runtimeMode=local)', async () => {
+    mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
+      result: {
+        runtimeKind: 'openclaw-cli',
+        openclawMode: 'gateway',
+        timeoutMs: 300000,
+        agentId: 'main',
+      },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
     });
-    mockIsRuntimeConfigError.mockReturnValueOnce(false);
 
     const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
     const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
@@ -270,6 +303,13 @@ describe('pd diagnose run --runtime routing', () => {
       json: false,
     } as DiagnoseRunOptions);
 
+    // Flag override: config says gateway, flag says local → adapter gets local
+    const OpenClawCliMock = vi.mocked(
+      await import('@principles/core/runtime-v2').then(m => m.OpenClawCliRuntimeAdapter),
+    );
+    expect(OpenClawCliMock).toHaveBeenCalledWith(
+      expect.objectContaining({ runtimeMode: 'local' }),
+    );
     expect(exitSpy).not.toHaveBeenCalledWith(1);
 
     consoleSpy.mockRestore();
@@ -277,13 +317,17 @@ describe('pd diagnose run --runtime routing', () => {
   });
 
   it('DPB-09: openclaw-cli missing mode (--json) outputs JSON error', async () => {
-    mockResolveRuntimeConfig.mockReturnValueOnce({
-      ok: false,
-      reason: 'missing_openclaw_mode',
-      message: 'runtimeKind is openclaw-cli but no mode specified',
-      nextAction: 'Provide exactly one mode',
+    mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
+      result: {
+        runtimeKind: 'openclaw-cli',
+        openclawMode: undefined,
+        timeoutMs: 300000,
+        agentId: 'main',
+      },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
     });
-    mockIsRuntimeConfigError.mockReturnValueOnce(true);
 
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
     const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
@@ -323,13 +367,17 @@ describe('pd diagnose run --runtime routing', () => {
   });
 
   it('DPB-09: openclaw-cli --openclaw-gateway constructs adapter with runtimeMode=gateway', async () => {
-    mockResolveRuntimeConfig.mockReturnValueOnce({
-      runtimeKind: 'openclaw-cli',
-      openclawMode: 'gateway',
-      timeoutMs: 300000,
-      agentId: 'main',
+    mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
+      result: {
+        runtimeKind: 'openclaw-cli',
+        openclawMode: 'gateway',
+        timeoutMs: 300000,
+        agentId: 'main',
+      },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
     });
-    mockIsRuntimeConfigError.mockReturnValueOnce(false);
 
     const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
     const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
@@ -355,13 +403,17 @@ describe('pd diagnose run --runtime routing', () => {
   });
 
   it('DPB-09: openclaw-cli --openclaw-local constructs adapter with runtimeMode=local', async () => {
-    mockResolveRuntimeConfig.mockReturnValueOnce({
-      runtimeKind: 'openclaw-cli',
-      openclawMode: 'local',
-      timeoutMs: 300000,
-      agentId: 'main',
+    mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
+      result: {
+        runtimeKind: 'openclaw-cli',
+        openclawMode: 'local',
+        timeoutMs: 300000,
+        agentId: 'main',
+      },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
     });
-    mockIsRuntimeConfigError.mockReturnValueOnce(false);
 
     const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
     const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);

package/tests/commands/pain-retry.test.ts

@@ -55,7 +55,7 @@ const { MockPrincipleTreeLedgerAdapter } = vi.hoisted(() => {
   return { MockPrincipleTreeLedgerAdapter };
 });
 
-const { mockRun, mockResolveRuntimeConfig } = vi.hoisted(() => {
+const { mockRun, mockResolveRuntimeConfig, mockResolveRuntimeFromPdConfig } = vi.hoisted(() => {
   const mockRun = vi.fn().mockResolvedValue({
     status: 'succeeded',
     taskId: 'diagnosis_test-pain-1',
@@ -70,7 +70,20 @@ const { mockRun, mockResolveRuntimeConfig } = vi.hoisted(() => {
     timeoutMs: 300000,
     agentId: 'main',
   });
-  return { mockRun, mockResolveRuntimeConfig };
+  const mockResolveRuntimeFromPdConfig = vi.fn().mockReturnValue({
+    result: {
+      runtimeKind: 'pi-ai',
+      provider: 'test-provider',
+      model: 'test-model',
+      apiKeyEnv: 'TEST_KEY',
+      timeoutMs: 300000,
+      agentId: 'main',
+    },
+    legacyWarnings: [],
+    configSource: '.pd/config.yaml',
+    configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
+  });
+  return { mockRun, mockResolveRuntimeConfig, mockResolveRuntimeFromPdConfig };
 });
 
 vi.mock('../../src/resolve-workspace.js', () => ({
@@ -128,6 +141,10 @@ vi.mock('../../src/config-reader.js', () => ({
   readOutputLanguageFromWorkspace: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
+vi.mock('../../src/services/resolve-runtime-from-pd-config.js', () => ({
+  resolveRuntimeFromPdConfig: mockResolveRuntimeFromPdConfig,
+}));
+
 import { handlePainRetry } from '../../src/commands/pain-retry.js';
 
 // ── Test Data ──────────────────────────────────────────────────────────────────
@@ -201,6 +218,19 @@ describe('pd pain retry — validation and error paths', () => {
       timeoutMs: 300000,
       agentId: 'main',
     });
+    mockResolveRuntimeFromPdConfig.mockReturnValue({
+      result: {
+        runtimeKind: 'pi-ai',
+        provider: 'test-provider',
+        model: 'test-model',
+        apiKeyEnv: 'TEST_KEY',
+        timeoutMs: 300000,
+        agentId: 'main',
+      },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
+    });
     mockGetTask.mockResolvedValue(null);
     mockGetCandidatesByTaskId.mockResolvedValue([]);
     mockUpdateCandidateStatus.mockResolvedValue(undefined);
@@ -342,11 +372,16 @@ describe('pd pain retry — validation and error paths', () => {
 
   it('RETRY-05a: missing --runtime and no config — refused with reason + nextAction (JSON)', async () => {
     mockGetTask.mockResolvedValue(RETRY_WAIT_TASK);
-    // Make resolveRuntimeConfig return an error so no runtime is resolved from config
-    mockResolveRuntimeConfig.mockReturnValueOnce({
-      reason: 'config_not_found',
-      message: 'No workflows.yaml found',
-      nextAction: 'Create workflows.yaml or pass --runtime',
+    // PRI-393: resolveRuntimeFromPdConfig returns error → no runtime resolved
+    mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
+      result: {
+        reason: 'config_not_found',
+        message: 'No .pd/config.yaml found',
+        nextAction: 'Create .pd/config.yaml or pass --runtime',
+      },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: false, effective: {}, defaults: {}, legacyFilesDetected: [] },
     });
 
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
@@ -404,14 +439,19 @@ describe('pd pain retry — validation and error paths', () => {
 
   it('RETRY-05c: blank provider/model/apiKeyEnv — refused with missing_required_config', async () => {
     mockGetTask.mockResolvedValue(RETRY_WAIT_TASK);
-    // Config returns blank strings for provider/model/apiKeyEnv
-    mockResolveRuntimeConfig.mockReturnValueOnce({
-      runtimeKind: 'pi-ai',
-      provider: '',
-      model: '   ',
-      apiKeyEnv: '',
-      timeoutMs: 300000,
-      agentId: 'main',
+    // PRI-393: resolveRuntimeFromPdConfig returns config with blank strings
+    mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
+      result: {
+        runtimeKind: 'pi-ai',
+        provider: '',
+        model: '   ',
+        apiKeyEnv: '',
+        timeoutMs: 300000,
+        agentId: 'main',
+      },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
     });
 
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
@@ -440,6 +480,81 @@ describe('pd pain retry — validation and error paths', () => {
     logSpy.mockRestore();
     exitSpy.mockRestore();
   });
+
+  it('DPB-09: openclaw-cli flag overrides file config mode (config=gateway, flag=local → runtimeMode=local)', async () => {
+    mockGetTask.mockResolvedValue(RETRY_WAIT_TASK);
+    mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
+      result: {
+        runtimeKind: 'openclaw-cli',
+        openclawMode: 'gateway',
+        timeoutMs: 300000,
+        agentId: 'main',
+      },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handlePainRetry({
+      painId: 'test-pain-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'openclaw-cli',
+      openclawLocal: true,
+      json: true,
+    });
+
+    // Flag override: config says gateway, flag says local → adapter gets local
+    const OpenClawCliMock = vi.mocked(
+      await import('@principles/core/runtime-v2').then(m => m.OpenClawCliRuntimeAdapter),
+    );
+    expect(OpenClawCliMock).toHaveBeenCalledWith(
+      expect.objectContaining({ runtimeMode: 'local' }),
+    );
+    expect(exitSpy).not.toHaveBeenCalledWith(1);
+
+    logSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('DPB-09: openclaw-cli flag overrides file config mode (config=local, flag=gateway → runtimeMode=gateway)', async () => {
+    mockGetTask.mockResolvedValue(RETRY_WAIT_TASK);
+    mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
+      result: {
+        runtimeKind: 'openclaw-cli',
+        openclawMode: 'local',
+        timeoutMs: 300000,
+        agentId: 'main',
+      },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handlePainRetry({
+      painId: 'test-pain-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'openclaw-cli',
+      openclawGateway: true,
+      json: true,
+    });
+
+    const OpenClawCliMock = vi.mocked(
+      await import('@principles/core/runtime-v2').then(m => m.OpenClawCliRuntimeAdapter),
+    );
+    expect(OpenClawCliMock).toHaveBeenCalledWith(
+      expect.objectContaining({ runtimeMode: 'gateway' }),
+    );
+    expect(exitSpy).not.toHaveBeenCalledWith(1);
+
+    logSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
 });
 
 describe('pd pain retry — success paths', () => {