@principles/pd-cli 1.143.0 → 1.145.0

package/tests/commands/codex-worker-registration.test.ts

@@ -0,0 +1,178 @@
+/**
+ * Command-registration / parser + functional tests for the PRI-624 Slice C
+ * Codex commands (cli-7): `pd codex ingest catch-up` and `pd codex worker`.
+ *
+ * Registration mirrors src/index.ts. Functional tests exercise the real
+ * handlers against a temp workspace: --json emits exactly one parseable
+ * JSON object (cli-1), flag-off skips carry reason + nextAction (cli-6), and
+ * failed paths mutate nothing.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { Command } from 'commander';
+import { getDefaultPdConfig } from '@principles/core/runtime-v2';
+
+function buildTestProgram(): Command {
+  const program = new Command();
+  const codex = program.command('codex');
+  codex.command('reconcile');
+  const ingest = codex.command('ingest');
+  ingest
+    .command('catch-up')
+    .option('-w, --workspace <path>', 'Workspace directory')
+    .option('--max-rollouts <n>', 'Maximum rollouts to catch up per pass (1-32, default 8)')
+    .option('--json', 'Output raw JSON')
+    .action(() => {});
+  codex
+    .command('worker')
+    .option('-w, --workspace <path>', 'Workspace directory')
+    .option('--once', 'Run exactly one bounded cycle and exit')
+    .option('--interval <ms>', 'Cycle interval for continuous mode')
+    .option('--status', 'Report the SPEC §15 worker mode without executing anything')
+    .option('--json', 'Output raw JSON')
+    .action(() => {});
+  return program;
+}
+
+describe('codex Slice C command registration (cli-7)', () => {
+  it('parses codex ingest catch-up flags', () => {
+    const program = buildTestProgram();
+    program.parse(['node', 'pd', 'codex', 'ingest', 'catch-up', '--workspace', '/tmp/ws', '--max-rollouts', '4', '--json']);
+    const codex = program.commands.find((c) => c.name() === 'codex');
+    const ingest = codex?.commands.find((c) => c.name() === 'ingest');
+    const catchUp = ingest?.commands.find((c) => c.name() === 'catch-up');
+    expect(catchUp).toBeDefined();
+    expect(catchUp?.opts().workspace).toBe('/tmp/ws');
+    expect(catchUp?.opts().maxRollouts).toBe('4');
+    expect(catchUp?.opts().json).toBe(true);
+  });
+
+  it('parses codex worker flags including --once and --status', () => {
+    const program = buildTestProgram();
+    program.parse(['node', 'pd', 'codex', 'worker', '--workspace', '/tmp/ws', '--once', '--json']);
+    const codex = program.commands.find((c) => c.name() === 'codex');
+    const worker = codex?.commands.find((c) => c.name() === 'worker');
+    expect(worker).toBeDefined();
+    expect(worker?.opts().workspace).toBe('/tmp/ws');
+    expect(worker?.opts().once).toBe(true);
+    expect(worker?.opts().json).toBe(true);
+
+    const program2 = buildTestProgram();
+    program2.parse(['node', 'pd', 'codex', 'worker', '--status']);
+    const worker2 = program2.commands.find((c) => c.name() === 'codex')?.commands.find((c) => c.name() === 'worker');
+    expect(worker2?.opts().status).toBe(true);
+    // --interval is registered for continuous mode
+    const intervalOption = worker?.options.find((o) => o.long === '--interval');
+    expect(intervalOption).toBeDefined();
+  });
+});
+
+describe('codex ingest catch-up handler (functional)', () => {
+  let workspaceDir: string;
+  let logSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-cli-catchup-'));
+    fs.mkdirSync(path.join(workspaceDir, '.pd'), { recursive: true });
+    fs.mkdirSync(path.join(workspaceDir, '.state'), { recursive: true });
+    fs.writeFileSync(path.join(workspaceDir, '.state', 'trajectory.db'), '');
+    const config = getDefaultPdConfig();
+    config.features['host.codex'].enabled = true;
+    config.features.codex_conversation_ingestion.enabled = false;
+    fs.writeFileSync(path.join(workspaceDir, '.pd', 'config.yaml'), JSON.stringify(config));
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+    fs.rmSync(workspaceDir, { recursive: true, force: true });
+  });
+
+  it('emits exactly one JSON object and skips with reason+nextAction when ingestion is off', { timeout: 20_000 }, async () => {
+    const { handleCodexIngestCatchUp } = await import('../../src/commands/codex-ingest-catchup.js');
+    await handleCodexIngestCatchUp({ workspace: workspaceDir, json: true });
+    expect(logSpy).toHaveBeenCalledTimes(1);
+    const report = JSON.parse(logSpy.mock.calls[0]?.[0] as string) as { status: string; reason: string; nextAction: string };
+    expect(report.status).toBe('skipped');
+    expect(report.reason).toBe('feature_disabled');
+    expect(report.nextAction).toContain('codex_conversation_ingestion');
+    expect(process.exitCode ?? 0).toBe(0);
+  });
+});
+
+describe('codex worker handler (functional)', () => {
+  let workspaceDir: string;
+  let logSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-cli-worker-'));
+    fs.mkdirSync(path.join(workspaceDir, '.pd'), { recursive: true });
+    fs.mkdirSync(path.join(workspaceDir, '.state'), { recursive: true });
+    fs.writeFileSync(path.join(workspaceDir, '.state', 'trajectory.db'), '');
+    const config = getDefaultPdConfig();
+    config.features['host.codex'].enabled = true;
+    config.features.internalization_auto_consumer.enabled = false;
+    fs.writeFileSync(path.join(workspaceDir, '.pd', 'config.yaml'), JSON.stringify(config));
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+    process.exitCode = 0;
+    fs.rmSync(workspaceDir, { recursive: true, force: true });
+  });
+
+  it('--once reports paused with reason+nextAction when the consumer flag is off', { timeout: 20_000 }, async () => {
+    const { handleCodexWorker } = await import('../../src/commands/codex-worker.js');
+    await handleCodexWorker({ workspace: workspaceDir, once: true, json: true });
+    expect(logSpy).toHaveBeenCalledTimes(1);
+    const report = JSON.parse(logSpy.mock.calls[0]?.[0] as string) as { mode: string; reason: string; nextAction: string };
+    expect(report.mode).toBe('paused');
+    expect(report.reason).toBe('internalization_auto_consumer_disabled');
+    expect(report.nextAction).toContain('pd diagnose');
+    expect(process.exitCode ?? 0).toBe(0);
+  });
+
+  it('--json without --once/--status is refused (continuous mode streams, it is not one JSON document)', async () => {
+    const { handleCodexWorker } = await import('../../src/commands/codex-worker.js');
+    await handleCodexWorker({ workspace: workspaceDir, json: true });
+    expect(logSpy).toHaveBeenCalledTimes(1);
+    const error = JSON.parse(logSpy.mock.calls[0]?.[0] as string) as { error: string; reason: string; nextAction: string };
+    expect(error.error).toBe('cli_contract');
+    expect(error.reason).toBe('json_without_once_or_status');
+    expect(error.nextAction).toContain('--once');
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('--once without --json prints the human-readable cycle report', { timeout: 20_000 }, async () => {
+    const { handleCodexWorker } = await import('../../src/commands/codex-worker.js');
+    await handleCodexWorker({ workspace: workspaceDir, once: true, json: false });
+    // Human-readable form: one multi-line report, no JSON envelope.
+    const output = logSpy.mock.calls.map((call) => String(call[0])).join('\n');
+    expect(output).toContain('Codex workspace worker');
+    expect(output).toContain('mode: paused');
+    expect(output).toContain('catch-up:');
+    expect(output).toContain('reconcile:');
+    expect(output).toContain('next action:');
+    expect(process.exitCode ?? 0).toBe(0);
+  });
+
+  it('--status reports manual_action_required for a workspace absent from the install manifest', async () => {
+    const { handleCodexWorker } = await import('../../src/commands/codex-worker.js');
+    // Execution enabled — the manifest absence is then the deciding fact.
+    const config = getDefaultPdConfig();
+    config.features['host.codex'].enabled = true;
+    config.features.internalization_auto_consumer.enabled = true;
+    fs.writeFileSync(path.join(workspaceDir, '.pd', 'config.yaml'), JSON.stringify(config));
+    await handleCodexWorker({ workspace: workspaceDir, status: true, json: true });
+    expect(logSpy).toHaveBeenCalledTimes(1);
+    const report = JSON.parse(logSpy.mock.calls[0]?.[0] as string) as { mode: string; reason: string; registeredInInstallManifest: boolean; nextAction: string };
+    expect(report.mode).toBe('manual_action_required');
+    expect(report.reason).toBe('workspace_not_in_install_manifest');
+    expect(report.registeredInInstallManifest).toBe(false);
+    expect(report.nextAction).toContain('pd codex ingest catch-up');
+    expect(process.exitCode ?? 0).toBe(0);
+  });
+});

package/tests/commands/console-open.test.ts

@@ -311,6 +311,46 @@ describe('planConsoleLaunch — reused (healthy console on preferred port)', ()
     }
   });
 
+  it('does not reuse a verified no-auth Console when a token is configured', async () => {
+    const server = http.createServer((_req, res) => {
+      res.statusCode = 200;
+      res.end(JSON.stringify({ success: true, data: { authenticationMode: 'no_auth' } }));
+    });
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const addr = server.address();
+    if (typeof addr !== 'object' || !addr) throw new Error('no addr');
+    try {
+      const result = await planConsoleLaunch({
+        workspaceDir: '/tmp/anywhere', preferredPort: addr.port,
+        host: '127.0.0.1', token: 'configured-token',
+      });
+      expect(result.status).toBe('refused');
+      expect(result.reason).toBe('console_authentication_mode_mismatch');
+    } finally {
+      await new Promise<void>((resolve) => server.close(resolve));
+    }
+  });
+
+  it('fails loud when the configured token is rejected by an existing Console', async () => {
+    const server = http.createServer((_req, res) => {
+      res.statusCode = 401;
+      res.end('unauthorized');
+    });
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const addr = server.address();
+    if (typeof addr !== 'object' || !addr) throw new Error('no addr');
+    try {
+      const result = await planConsoleLaunch({
+        workspaceDir: '/tmp/anywhere', preferredPort: addr.port,
+        host: '127.0.0.1', token: 'wrong-token',
+      });
+      expect(result.status).toBe('refused');
+      expect(result.reason).toBe('console_authentication_failed');
+    } finally {
+      await new Promise<void>((resolve) => server.close(resolve));
+    }
+  });
+
   it('does NOT classify a non-console responder as reused', async () => {
     // Server returns 200 on any path but with a non-OK status code from /api/health
     const server = http.createServer((req, res) => {
@@ -387,6 +427,22 @@ describe('probeConsoleHealth', () => {
     }
   });
 
+  it('returns the verified authentication mode from the health contract', async () => {
+    const server = http.createServer((_req, res) => {
+      res.statusCode = 200;
+      res.end(JSON.stringify({ success: true, data: { authenticationMode: 'authenticated' } }));
+    });
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const addr = server.address();
+    if (typeof addr !== 'object' || !addr) throw new Error('no addr');
+    try {
+      const h = await probeConsoleHealth({ host: '127.0.0.1', port: addr.port, token: 'token' });
+      expect(h).toMatchObject({ healthy: true, authenticationMode: 'authenticated' });
+    } finally {
+      await new Promise<void>((resolve) => server.close(resolve));
+    }
+  });
+
   it('returns healthy=false with reason for a server that returns 500', async () => {
     const server = http.createServer((req, res) => {
       res.statusCode = 500;
@@ -491,8 +547,11 @@ describe('CLI command wiring (pd console open)', () => {
   let cliPath: string;
   let workspaceRoot: string;
   let tmp: string;
+  let originalConsoleToken: string | undefined;
 
   beforeEach(() => {
+    originalConsoleToken = process.env.PD_CONSOLE_TOKEN;
+    delete process.env.PD_CONSOLE_TOKEN;
     workspaceRoot = path.resolve(__dirname, '../../../..');
     cliPath = path.join(workspaceRoot, 'packages', 'pd-cli', 'dist', 'index.js');
     tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-console-open-test-'));
@@ -520,7 +579,7 @@ describe('CLI command wiring (pd console open)', () => {
       const server = http.createServer((req, res) => {
         if (req.url === '/api/health') {
           res.writeHead(200, {'Content-Type': 'application/json'});
-          res.end(JSON.stringify({success: true}));
+          res.end(JSON.stringify({success: true, data: {authenticationMode: 'no_auth'}}));
         } else {
           res.writeHead(404);
           res.end();
@@ -533,6 +592,8 @@ describe('CLI command wiring (pd console open)', () => {
   });
 
   afterEach(() => {
+    if (originalConsoleToken === undefined) delete process.env.PD_CONSOLE_TOKEN;
+    else process.env.PD_CONSOLE_TOKEN = originalConsoleToken;
     delete process.env.__PD_CONSOLE_TEST_FAKE_HOME;
     try { fs.rmSync(tmp, { recursive: true, force: true }); } catch { /* ignore */ }
   });
@@ -598,13 +659,32 @@ describe('CLI command wiring (pd console open)', () => {
     }
   }, 20_000);
 
+  it('kills and refuses a fresh Console whose reported authentication mode mismatches the configured token', async () => {
+    process.env.PD_CONSOLE_TOKEN = 'configured-token';
+    let run: CliJsonRun | undefined;
+    try {
+      run = await runPdUntilJson(
+        ['console', 'open', '--workspace', tmp, '--port', '49391', '--json', '--no-browser'],
+        workspaceRoot,
+      );
+      if (!isRecord(run.parsed)) throw new Error('CLI JSON output was not an object');
+      expect(run.parsed.status).toBe('refused');
+      expect(run.parsed.reason).toBe('console_authentication_mode_mismatch');
+      expect(run.parsed).not.toHaveProperty('serverPid');
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      expect(await isPortInUse('127.0.0.1', 49391)).toBe(false);
+    } finally {
+      await teardownCliTree(run);
+    }
+  }, 20_000);
+
   it('pd console open --json reused path does NOT include serverPid (PRI-526)', async () => {
     // Stand up a fake healthy console in-process, then point the CLI at its
     // port: planConsoleLaunch probes /api/health → 200 → reused, no spawn.
     const server = http.createServer((req, res) => {
       if (req.url === '/api/health') {
         res.statusCode = 200;
-        res.end(JSON.stringify({ success: true }));
+        res.end(JSON.stringify({ success: true, data: { authenticationMode: 'no_auth' } }));
         return;
       }
       res.statusCode = 404;
@@ -622,6 +702,7 @@ describe('CLI command wiring (pd console open)', () => {
       if (!isRecord(run.parsed)) throw new Error('CLI JSON output was not an object');
       expect(run.parsed.status).toBe('reused');
       expect(run.parsed.reused).toBe(true);
+      expect(run.parsed.authenticationMode).toBe('no_auth');
       expect(run.parsed).not.toHaveProperty('serverPid');
     } finally {
       await teardownCliTree(run);

package/tests/commands/health.test.ts

@@ -39,6 +39,10 @@ vi.mock('@principles/core/runtime-v2', () => ({
   }),
   auditCandidateLedgerConsistency: mockAuditCandidateLedgerConsistency,
   resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
+  // host-runtime's workspace-telemetry-emitter (transitively imported via the
+  // host-runtime barrel) extends this class at module-load time — the mock
+  // must provide a constructible base or the import chain throws.
+  StoreEventEmitter: class {},
 }));
 
 // PRI-443 Phase 5: getLedgerFilePathPublic now imported from