codehere 0.3.0-rc.2 → 0.3.0-rc.27

package/dist/infrastructure/orchestration/generic-cli-adapter.js

@@ -478,7 +478,6 @@ export function compileSafePattern(source, fallback, agentId) {
     // Layer 1 · static shape check — this is the only fully reliable defense.
     const danger = detectRedosShape(source);
     if (danger) {
-        // eslint-disable-next-line no-console
         console.warn(`[codehere] Regex for "${agentId}" rejected (${danger}) — using fallback`);
         return fallback;
     }
@@ -487,7 +486,6 @@ export function compileSafePattern(source, fallback, agentId) {
         candidate = new RegExp(source);
     }
     catch {
-        // eslint-disable-next-line no-console
         console.warn(`[codehere] Invalid regex in agents.yaml for "${agentId}" — using fallback`);
         return fallback;
     }
@@ -496,7 +494,6 @@ export function compileSafePattern(source, fallback, agentId) {
         const start = Date.now();
         candidate.test('a'.repeat(1000));
         if (Date.now() - start > 100) {
-            // eslint-disable-next-line no-console
             console.warn(`[codehere] Regex for "${agentId}" too slow (likely ReDoS) — using fallback`);
             return fallback;
         }

package/dist/infrastructure/orchestration/session-manager.js

@@ -18,6 +18,7 @@ import { CodexAdapter } from './codex-adapter.js';
 import { AiderAdapter } from './aider-adapter.js';
 import { OpenCodeAdapter } from './opencode-adapter.js';
 import { buildGenericAdapter, loadAgentsConfig } from './generic-cli-adapter.js';
+import { buildConductorAdapter } from './conductor-adapter.js';
 import { seedAgentsConfig } from './agents-config-seed.js';
 import { AUDIT_FILE } from '../hooks/claude-sdk-hook.js';
 import { appendSpawned, appendCompleted, loadRecent } from './session-persistence.js';
@@ -37,6 +38,11 @@ const REGISTRY = [
     // popular CLI agents above. Users can add/edit/remove entries freely.
     ...loadAgentsConfig().map(buildGenericAdapter),
 ];
+// F6 Conductor — the meta-agent. Registered LAST so it sees the full registry
+// at lookup time. The lookup function is closed over `REGISTRY` so it always
+// returns the current populated array (including any future user adapters).
+// Conductor is appended to the same array so UIs that iterate REGISTRY see it.
+REGISTRY.push(buildConductorAdapter(() => REGISTRY));
 export function availableAgents() {
     return REGISTRY.map((a) => ({ id: a.id, label: a.label, installed: a.isInstalled() }));
 }

package/dist/infrastructure/protocols/mcp-server-impl.js

@@ -20,7 +20,8 @@
  */
 import http from 'http';
 import { readFileSync, existsSync, statSync, watchFile, unwatchFile } from 'fs';
-import { join, relative } from 'path';
+import { join, relative, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { collectFilesForMCP, scoreFileForMCP } from './mcp-helpers.js';
 import { scanPayload, calculateRiskScore, AUDIT_FILE } from '../hooks/claude-sdk-hook.js';
 import { getVersion } from '../../utils/version.js';
@@ -589,8 +590,14 @@ export function startMCPServer(options = {}) {
             res.end(JSON.stringify({ error: 'Method not allowed for this path' }));
             return;
         }
-        // MCP endpoint
-        if (req.method === 'POST' && req.url === '/mcp') {
+        // MCP endpoint — POST jsonrpc; reject other verbs with 405 + Allow header
+        // (rc.17: was 404, which is wrong HTTP semantic — UX_OBSERVATIONS P3).
+        if (req.url === '/mcp') {
+            if (req.method !== 'POST') {
+                res.writeHead(405, { 'Content-Type': 'application/json', Allow: 'POST' });
+                res.end(JSON.stringify({ error: 'MCP endpoint accepts POST only', method: req.method }));
+                return;
+            }
             let body = '';
             req.on('data', (chunk) => {
                 body += chunk;
@@ -612,6 +619,29 @@ export function startMCPServer(options = {}) {
             });
             return;
         }
+        // /api/version — small completeness item for ops monitoring (rc.17).
+        // ESM-friendly: resolve package.json relative to the compiled module's
+        // own URL via fileURLToPath. Works in both src/ (during dev) and dist/
+        // because the relative path up to package.json is the same in both.
+        if (req.url === '/api/version' && req.method === 'GET') {
+            try {
+                const moduleDir = dirname(fileURLToPath(import.meta.url));
+                const pkgPath = join(moduleDir, '..', '..', '..', 'package.json');
+                const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ version: pkg.version, name: pkg.name }));
+            }
+            catch (e) {
+                // rc.19: don't leak fs paths to the public HTTP surface.
+                // rc.20: but DO log the actual error context for the operator (Codex
+                // rc.19 review caught: previous version dropped `e` and logged only a
+                // static string, costing diagnosability).
+                console.error('[/api/version] failed to read package metadata:', e);
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Failed to read package metadata' }));
+            }
+            return;
+        }
         // 404
         res.writeHead(404);
         res.end();

package/dist/infrastructure/protocols/probe-port.js

@@ -0,0 +1,36 @@
+/**
+ * Detect whether a given host:port is already serving a codehere instance.
+ *
+ * Used by `codehere start` when the listen() fails with EADDRINUSE: we'd
+ * rather give the user a friendly "codehere already running, opening browser"
+ * than a Node stack trace. If something ELSE holds the port we tell them to
+ * pick a different one.
+ *
+ * Approach: hit the existing server's /health endpoint. The codehere MCP
+ * server returns a JSON body with `server: 'codehere-mcp'` — no other tool
+ * uses that exact identifier. Generous 1.5-second timeout so a slow loopback
+ * doesn't false-negative.
+ */
+export async function isCodehereOnPort(host, port, timeoutMs = 1500) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeoutMs);
+    try {
+        const res = await fetch(`http://${host}:${port}/health`, { signal: ac.signal });
+        if (!res.ok)
+            return { isCodehere: false };
+        const body = (await res.json());
+        if (body?.server === 'codehere-mcp') {
+            return { isCodehere: true, version: body.version };
+        }
+        return { isCodehere: false };
+    }
+    catch {
+        // Connection refused, timeout, malformed response — anything that's not
+        // a positive codehere identification. Treat as "not codehere."
+        return { isCodehere: false };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=probe-port.js.map

package/dist/infrastructure/security/file-collection.js

@@ -62,6 +62,9 @@ export const IGNORE_DIRS = new Set([
     '.cache',
     '.codehere',
     '.codehere-cache',
+    // Cloned reference repos used for dogfooding / comparison — not the user's code.
+    // Codehere convention; mirrors how `.git` is hidden tooling-data, not source.
+    '.oss-repos',
     // Test fixtures / mocks (intentionally-vulnerable code used as scanner inputs)
     'fixtures',
     'test-fixtures',

package/dist/presentation/cli/commands/report-command.js

@@ -237,14 +237,61 @@ function generateSimpleReport(report, target) {
     lines.push('Generated by codehere — know what your AI agent did before your tech lead asks.');
     return lines.join('\n');
 }
+/**
+ * Write report to the requested path. If the path is unwritable (EROFS,
+ * EACCES, EPERM, ENOENT on a parent dir we can't create), fall back to
+ * stdout so the user still gets the report instead of a stack trace.
+ *
+ * Returns true if the file was written, false if we fell back to stdout.
+ *
+ * Provoked by rc.25 UAT: `codehere report --simple` from `/` crashed with
+ * `EROFS: read-only file system, open 'codehere-audit.md'`. A user running
+ * the command from any unwritable cwd should still get their report.
+ */
+function writeReportWithFallback(targetPath, content, label) {
+    try {
+        writeFileSync(targetPath, content);
+        console.log(success(`${label} written to ${targetPath}`));
+        return true;
+    }
+    catch (e) {
+        const code = e.code ?? '';
+        if (['EROFS', 'EACCES', 'EPERM', 'ENOENT'].includes(code)) {
+            console.error(error(`Could not write to ${targetPath} (${code}). Printing to stdout instead — pass --out <path> to a writable location.`));
+            process.stdout.write(content + '\n');
+            return false;
+        }
+        throw e;
+    }
+}
 export async function executeReportCommand(target, options = {}) {
     const cwd = process.cwd();
     const resolved = target ? (isAbsolute(target) ? target : join(cwd, target)) : cwd;
-    // Default: write to a file so the user gets a shareable artifact instead of
-    // raw markdown sprayed at the terminal. --stdout opts into the old behavior
-    // for piping; --out overrides the default path.
-    const defaultOutName = options.json ? 'codehere-audit.json' : 'codehere-audit.md';
-    const effectiveOut = options.stdout ? undefined : (options.out ?? defaultOutName);
+    // rc.18: explicit mutex on combinations Codex flagged as silently
+    // ambiguous. Two pairs:
+    //   format    {--json, --simple} — pick at most one output format
+    //   dest      {--stdout, --out}   — pick at most one destination
+    // Previously the second flag silently lost; now we error so users know.
+    if (options.json && options.simple) {
+        console.error(error('--json and --simple cannot be used together. Pick one output format.'));
+        process.exit(2);
+    }
+    if (options.stdout && options.out) {
+        console.error(error('--stdout and --out cannot be used together. Pick one destination.'));
+        process.exit(2);
+    }
+    // Default routing rules (after mutex check):
+    //   --json            → stdout (pipeable to jq, every CLI convention).
+    //   --simple / md     → file (user expects a shareable artifact, not a wall of markdown).
+    //   --out <path>      → wins over the default (explicit beats default).
+    //   --stdout          → forces stdout for non-json formats.
+    // Rationale: rc.15 — `report --json` writing to disk silently broke pipelines
+    // (`codehere report --json | jq` produced empty stdout). Stdout for machine-
+    // readable formats matches `kubectl get -o json`, `docker inspect`, etc.
+    const defaultOut = options.json
+        ? undefined // stdout
+        : 'codehere-audit.md';
+    const effectiveOut = options.stdout ? undefined : (options.out ?? defaultOut);
     if (!existsSync(resolved)) {
         console.error(error(`Not found: ${resolved}`));
         process.exit(1);
@@ -297,8 +344,7 @@ export async function executeReportCommand(target, options = {}) {
     if (options.json) {
         const output = JSON.stringify(report, null, 2);
         if (effectiveOut) {
-            writeFileSync(effectiveOut, output);
-            console.log(success(`Report written to ${effectiveOut}`));
+            writeReportWithFallback(effectiveOut, output, 'Report');
         }
         else {
             console.log(output);
@@ -309,8 +355,7 @@ export async function executeReportCommand(target, options = {}) {
     if (options.simple) {
         const simple = generateSimpleReport(report, resolved);
         if (effectiveOut) {
-            writeFileSync(effectiveOut, simple);
-            console.log(success(`Plain-English report written to ${effectiveOut}`));
+            writeReportWithFallback(effectiveOut, simple, 'Plain-English report');
         }
         else {
             process.stdout.write(simple + '\n');
@@ -320,9 +365,9 @@ export async function executeReportCommand(target, options = {}) {
     // Markdown output
     const markdown = generateMarkdown(report, resolved, cwd);
     if (effectiveOut) {
-        writeFileSync(effectiveOut, markdown);
+        if (!writeReportWithFallback(effectiveOut, markdown, 'Report'))
+            return;
         newline();
-        console.log(success(`Report written to ${effectiveOut}`));
         console.log(colors.dim(`  ${paths.length} files · score ${overallScore}/100 · grade ${grade}`));
         if (criticalCount > 0) {
             console.log(colors.red(`  ${criticalCount} critical issue${criticalCount !== 1 ? 's' : ''} — check the report`));

package/dist/presentation/cli/commands/status-command.js

@@ -148,9 +148,14 @@ function renderSessionDrillDown(sessionId, entries) {
         console.log(`  ${icon}  ${time}  ${tool}  ${colors.dim(reason)}`);
     }
     newline();
-    // Verdict
-    if (blocked.length > 2 && sorted.length > 20) {
-        console.log(colors.red('  ⚠ High block rate in a long session — possible prompt injection in multi-agent chain.'));
+    // Verdict — rc.17: tighten "injection" claim to actual high block ratio
+    // (UX_OBSERVATIONS.md P1; long attended sessions shouldn't get accused).
+    if (blocked.length > 2 && sorted.length > 20 && blocked.length / sorted.length > 0.05) {
+        const pct = ((blocked.length / sorted.length) * 100).toFixed(0);
+        console.log(colors.red(`  ⚠ ${pct}% block rate (${blocked.length}/${sorted.length}) — review for injection patterns.`));
+    }
+    else if (blocked.length > 0 && sorted.length > 20) {
+        console.log(colors.yellow(`  ${blocked.length} blocked / ${sorted.length} total — long session, review if unattended.`));
     }
     else if (blocked.length > 0) {
         console.log(colors.yellow(`  ${blocked.length} blocked call${blocked.length !== 1 ? 's' : ''} — review the blocked entries above.`));
@@ -413,6 +418,13 @@ export async function executeStatusCommand(options = {}) {
     const cwd = process.cwd();
     const version = getVersion();
     const entries = readAuditLog();
+    // Validate --since up front — applies to ALL modes, not just --export.
+    // (rc.15 fix: previously the validation ran only inside the --export branch,
+    // so `codehere status --since bogus` silently succeeded with exit 0.)
+    if (options.since && parseDurationToHours(options.since) == null) {
+        console.error(`Invalid --since value: "${options.since}". Use e.g. 24h, 7d, 4w.`);
+        process.exit(1);
+    }
     // Session drill-down mode
     if (options.session) {
         renderSessionDrillDown(options.session, entries);
@@ -421,10 +433,6 @@ export async function executeStatusCommand(options = {}) {
     // Audit export mode — dump raw events for archival/compliance/sharing
     if (options.export) {
         const sinceHours = options.since ? parseDurationToHours(options.since) : null;
-        if (options.since && sinceHours == null) {
-            console.error(`Invalid --since value: "${options.since}". Use e.g. 24h, 7d, 4w.`);
-            process.exit(1);
-        }
         try {
             exportAudit(entries, options.export, sinceHours);
         }
@@ -480,9 +488,17 @@ export async function executeStatusCommand(options = {}) {
                 }));
                 result.taskCount = tasks.length;
             }
-            catch {
+            catch (e) {
+                // rc.25: JSON consumers reading only stdout were still being fed a
+                // lie ([] tasks, 0 count) on real failure (Codex final review:
+                // "degraded behavior being presented as success"). Now we surface a
+                // structured taskLoadError + status:'degraded' so automation can
+                // distinguish "no tasks" from "load failed."
+                console.error('[status --tasks --json] task repository failed to load:', e);
                 result.tasks = [];
                 result.taskCount = 0;
+                result.taskLoadError = e instanceof Error ? e.message : String(e);
+                result.status = 'degraded';
             }
         }
         console.log(JSON.stringify(result, null, 2));
@@ -630,8 +646,14 @@ export async function executeStatusCommand(options = {}) {
                 }
             }
         }
-        catch {
-            console.log(colors.dim('No tasks found. Run "codehere start" to open the task intake, or "codehere task <prompt>" from the CLI.'));
+        catch (e) {
+            // rc.25: don't print "No tasks found" — that's a lie when load failed
+            // (Codex final review: "degraded behavior presented as success"). Show
+            // a clear error line; stderr already has the cause for the operator.
+            console.error('[status] task repository failed to load:', e);
+            const msg = e instanceof Error ? e.message : String(e);
+            console.log(colors.red(`  ✗ Could not load task repository: ${msg}`));
+            console.log(colors.dim('  See logs above for details. Try `codehere start` to (re)init the task intake.'));
         }
     }
     // Quick trust scan (opt-in)