@moretea-labs/forge 1.7.1 → 1.8.0

package/adapters/mcp/policy.ts

@@ -0,0 +1,232 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { DEFAULT_AGENT_TIMEOUT_MS, defaultLocalAgentRunners, MAX_AGENT_TIMEOUT_MS } from '../../src/cli/controller/runtime-config';
+import type { McpAgentRunnerName, McpPolicy, McpProfileName } from './types';
+
+const COMMON_DENY_GLOBS = [
+  '.env',
+  '.env.*',
+  '*.pem',
+  '*.key',
+  '*.p12',
+  '*.pfx',
+  '.ssh/**',
+  '.git/**',
+  'node_modules/**',
+  'dist/**',
+  'build/**',
+  'coverage/**',
+  'secrets/**',
+  'credentials/**',
+  'private/**',
+  '.cache/**',
+  '.DS_Store',
+];
+
+export const PLANNER_READ_GLOBS = [
+  'AGENTS.md',
+  'CLAUDE.md',
+  'SKILL.md',
+  'docs/spec.md',
+  'docs/reference-configs/**',
+  'plans/**',
+  'tasks/current.md',
+  'tasks/contracts/**',
+  'tasks/reviews/**',
+  'tasks/notes/**',
+  '.ai/context/**',
+  '.ai/harness/session/**',
+  '.ai/harness/controller/packets/**',
+  '.ai/harness/projections/**',
+  '.ai/harness/checks/**',
+];
+
+export const PLANNER_WRITE_GLOBS = [
+  'plans/prds/**',
+  'plans/sprints/**',
+  'plans/plan-*.md',
+  '.ai/harness/controller/packets/codex-goal.md',
+  '.ai/harness/controller/packets/chatgpt-plan.md',
+];
+
+export interface McpPolicyOptions {
+  devAgentRunner?: boolean;
+  allowedAgents?: McpAgentRunnerName[];
+  runnerTimeoutMs?: number;
+  runnerMaxTimeoutMs?: number;
+  repoRoot?: string;
+}
+
+interface McpPolicyOverrideProfile {
+  readGlobs?: string[];
+  writeGlobs?: string[];
+  denyGlobs?: string[];
+  appendReadGlobs?: string[];
+  appendWriteGlobs?: string[];
+  appendDenyGlobs?: string[];
+  maxFileBytes?: number;
+}
+
+interface McpPolicyOverrideFile {
+  profiles?: Partial<Record<McpProfileName, McpPolicyOverrideProfile>>;
+}
+
+function executionPolicy(overrides: Partial<McpPolicy['execution']> = {}): McpPolicy['execution'] {
+  return {
+    fixedWorkflowCheck: false,
+    codexRunner: false,
+    agentRunner: false,
+    allowedAgents: [],
+    runnerTimeoutMs: DEFAULT_AGENT_TIMEOUT_MS,
+    runnerMaxTimeoutMs: MAX_AGENT_TIMEOUT_MS,
+    ...overrides,
+  };
+}
+
+function uniqueStrings(values: string[]): string[] {
+  return Array.from(new Set(values.filter((value) => value.trim().length > 0)));
+}
+
+function parseStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const normalized = value.map((entry) => String(entry).trim()).filter((entry) => entry.length > 0);
+  return normalized;
+}
+
+function loadMcpPolicyOverrides(repoRoot?: string): McpPolicyOverrideFile | undefined {
+  if (!repoRoot) return undefined;
+  const path = join(repoRoot, '.forge', 'mcp.policy.json');
+  if (!existsSync(path)) return undefined;
+  const raw = JSON.parse(readFileSync(path, 'utf-8')) as Record<string, unknown>;
+  const profilesRaw = raw.profiles;
+  if (!profilesRaw || typeof profilesRaw !== 'object' || Array.isArray(profilesRaw)) return undefined;
+  const profiles: Partial<Record<McpProfileName, McpPolicyOverrideProfile>> = {};
+  for (const profile of ['planner', 'executor', 'orchestrator', 'controller'] as const) {
+    const entry = (profilesRaw as Record<string, unknown>)[profile];
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue;
+    const record = entry as Record<string, unknown>;
+    const maxFileBytes = typeof record.maxFileBytes === 'number' && Number.isFinite(record.maxFileBytes)
+      ? Math.trunc(record.maxFileBytes)
+      : undefined;
+    profiles[profile] = {
+      readGlobs: parseStringArray(record.readGlobs),
+      writeGlobs: parseStringArray(record.writeGlobs),
+      denyGlobs: parseStringArray(record.denyGlobs),
+      appendReadGlobs: parseStringArray(record.appendReadGlobs),
+      appendWriteGlobs: parseStringArray(record.appendWriteGlobs),
+      appendDenyGlobs: parseStringArray(record.appendDenyGlobs),
+      maxFileBytes,
+    };
+  }
+  return { profiles };
+}
+
+function applyPolicyOverrides(
+  base: McpPolicy,
+  profile: McpProfileName,
+  repoRoot?: string,
+): McpPolicy {
+  const override = loadMcpPolicyOverrides(repoRoot)?.profiles?.[profile];
+  if (!override) return base;
+  return {
+    ...base,
+    readGlobs: uniqueStrings([...(override.readGlobs ?? base.readGlobs), ...(override.appendReadGlobs ?? [])]),
+    writeGlobs: uniqueStrings([...(override.writeGlobs ?? base.writeGlobs), ...(override.appendWriteGlobs ?? [])]),
+    denyGlobs: uniqueStrings([...COMMON_DENY_GLOBS, ...(override.denyGlobs ?? base.denyGlobs), ...(override.appendDenyGlobs ?? [])]),
+    maxFileBytes: override.maxFileBytes ?? base.maxFileBytes,
+  };
+}
+
+export function getMcpPolicy(profile: McpProfileName, opts: McpPolicyOptions = {}): McpPolicy {
+  if (profile === 'planner') {
+    return applyPolicyOverrides({
+      profile,
+      readGlobs: PLANNER_READ_GLOBS,
+      writeGlobs: PLANNER_WRITE_GLOBS,
+      denyGlobs: [
+        ...COMMON_DENY_GLOBS,
+        'src/**',
+        'app/**',
+        'packages/**',
+        'package.json',
+        'bun.lock',
+        'package-lock.json',
+        'pnpm-lock.yaml',
+        'yarn.lock',
+        '.github/workflows/**',
+      ],
+      maxFileBytes: 512 * 1024,
+      execution: executionPolicy({
+        fixedWorkflowCheck: true,
+      }),
+    }, profile, opts.repoRoot);
+  }
+
+  if (profile === 'executor') {
+    return applyPolicyOverrides({
+      profile,
+      readGlobs: ['plans/**', 'tasks/**', 'docs/spec.md', '.ai/context/**', '.ai/harness/**'],
+      writeGlobs: ['tasks/reviews/**', '.ai/harness/checks/**', '.ai/harness/session/**', '.ai/harness/controller/packets/**'],
+      denyGlobs: COMMON_DENY_GLOBS,
+      maxFileBytes: 512 * 1024,
+      execution: executionPolicy({
+        fixedWorkflowCheck: true,
+      }),
+    }, profile, opts.repoRoot);
+  }
+
+  if (profile === 'controller') {
+    const devRunner = opts.devAgentRunner === true;
+    return applyPolicyOverrides({
+      profile,
+      readGlobs: ['**'],
+      writeGlobs: ['**'],
+      denyGlobs: [
+        ...COMMON_DENY_GLOBS,
+        '.forge/**',
+        '.ai/harness/security/**',
+        '.codex/**',
+        '.claude/**',
+        'package-lock.json',
+        'pnpm-lock.yaml',
+        'yarn.lock',
+        'bun.lock',
+        '.github/workflows/**',
+      ],
+      maxFileBytes: 2 * 1024 * 1024,
+      execution: executionPolicy({
+        fixedWorkflowCheck: true,
+        codexRunner: devRunner,
+        agentRunner: devRunner,
+        allowedAgents: devRunner ? (opts.allowedAgents?.length ? opts.allowedAgents : defaultLocalAgentRunners()) : [],
+        runnerTimeoutMs: opts.runnerTimeoutMs ?? DEFAULT_AGENT_TIMEOUT_MS,
+        runnerMaxTimeoutMs: opts.runnerMaxTimeoutMs ?? MAX_AGENT_TIMEOUT_MS,
+      }),
+    }, profile, opts.repoRoot);
+  }
+
+  if (profile === 'orchestrator') {
+    const devRunner = opts.devAgentRunner === true;
+    return applyPolicyOverrides({
+      profile,
+      readGlobs: devRunner ? ['.ai/harness/controller/packets/codex-goal.md'] : [],
+      writeGlobs: [],
+      denyGlobs: devRunner ? COMMON_DENY_GLOBS : ['**'],
+      maxFileBytes: devRunner ? 512 * 1024 : 0,
+      execution: executionPolicy({
+        codexRunner: devRunner,
+        agentRunner: devRunner,
+        allowedAgents: devRunner ? (opts.allowedAgents?.length ? opts.allowedAgents : defaultLocalAgentRunners()) : [],
+        runnerTimeoutMs: opts.runnerTimeoutMs ?? DEFAULT_AGENT_TIMEOUT_MS,
+        runnerMaxTimeoutMs: opts.runnerMaxTimeoutMs ?? MAX_AGENT_TIMEOUT_MS,
+      }),
+    }, profile, opts.repoRoot);
+  }
+
+  throw new Error(`unknown MCP profile: ${String(profile)}`);
+}
+
+export function parseMcpProfile(value: string): McpProfileName {
+  if (value === 'planner' || value === 'executor' || value === 'orchestrator' || value === 'controller') return value;
+  throw new Error(`invalid MCP profile "${value}" (expected: planner, executor, orchestrator, controller)`);
+}

package/adapters/mcp/proxy-env.ts

@@ -0,0 +1,62 @@
+/**
+ * Local HTTP/SOCKS proxies must not intercept Tailscale Funnel / MagicDNS or
+ * loopback controller surfaces. Bun fetch does not honor `*.ts.net` wildcards;
+ * leading-dot forms (`.ts.net`) are required for reliable bypass.
+ */
+export const DIRECT_NETWORK_NO_PROXY_ENTRIES = [
+  '127.0.0.1',
+  'localhost',
+  '::1',
+  '.local',
+  '.ts.net',
+  '*.ts.net',
+  '.tailscale.com',
+  '*.tailscale.com',
+  '100.64.0.0/10',
+] as const;
+
+export function mergeNoProxy(...parts: Array<string | undefined | null>): string {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const part of parts) {
+    if (!part) continue;
+    for (const entry of part.split(',').map((item) => item.trim()).filter(Boolean)) {
+      const key = entry.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(entry);
+    }
+  }
+  return out.join(',');
+}
+
+/**
+ * Return a copy of `env` with NO_PROXY/no_proxy extended so local MCP, Tailscale
+ * Funnel, and MagicDNS health probes never go through a system HTTP proxy.
+ */
+export function withDirectNetworkProxyBypass(
+  env: NodeJS.ProcessEnv = process.env,
+): NodeJS.ProcessEnv {
+  const merged = mergeNoProxy(
+    env.NO_PROXY,
+    env.no_proxy,
+    ...DIRECT_NETWORK_NO_PROXY_ENTRIES,
+  );
+  return {
+    ...env,
+    NO_PROXY: merged,
+    no_proxy: merged,
+  };
+}
+
+/**
+ * Mutate the current process env in place (keepalive/supervisor long-running paths).
+ */
+export function applyDirectNetworkProxyBypass(
+  env: NodeJS.ProcessEnv = process.env,
+): NodeJS.ProcessEnv {
+  const next = withDirectNetworkProxyBypass(env);
+  env.NO_PROXY = next.NO_PROXY;
+  env.no_proxy = next.no_proxy;
+  return env;
+}

package/adapters/mcp/readiness-projection.ts

@@ -0,0 +1,24 @@
+import type { TaskLedgerProjection } from '../../src/cli/controller/task-ledger';
+import {
+  reconcileProjectionWithTaskLedger,
+  type RepositoryRuntimeProjectionSnapshot,
+} from '../../src/runtime/projections/materialized-view';
+
+/**
+ * Readiness must stay independent from the legacy Issue/Task board after the
+ * Requirement portfolio cutover. The persisted runtime projection remains the
+ * readiness source; Task Ledger comparison is optional diagnostic evidence.
+ */
+export function reconcileReadinessProjectionSource(
+  snapshot: RepositoryRuntimeProjectionSnapshot,
+  ledger?: TaskLedgerProjection,
+) {
+  if (!ledger) {
+    return {
+      status: 'unknown' as const,
+      projectionRunningWorkers: Math.max(0, snapshot.projection.runningWorkers),
+      detail: 'legacy task ledger retired; readiness uses persisted projection state',
+    };
+  }
+  return reconcileProjectionWithTaskLedger(snapshot, ledger);
+}

package/adapters/mcp/redaction.ts

@@ -0,0 +1,21 @@
+import { redactSensitiveText } from '../../src/runtime/evidence/sensitive-output';
+
+export interface McpRedaction {
+  type: string;
+  count: number;
+}
+
+export interface McpRedactionResult {
+  text: string;
+  redactions: McpRedaction[];
+}
+
+/**
+ * MCP is a presentation boundary, not a separate secret-detection engine.
+ * Reuse the same bounded patterns as Process Runtime persistence so a value
+ * cannot be safe in one tool surface and exposed in another.
+ */
+export function redactMcpText(input: string): McpRedactionResult {
+  const result = redactSensitiveText(input);
+  return { text: result.text, redactions: result.redactions };
+}

package/adapters/mcp/repo.ts

@@ -0,0 +1,24 @@
+import { existsSync } from 'fs';
+import { join, resolve } from 'path';
+import { runProcess } from '../../src/effects/process-runner';
+
+export function resolveMcpRepoRoot(repo = '.'): string {
+  const candidate = resolve(repo);
+  const result = runProcess('git', ['-C', candidate, 'rev-parse', '--show-toplevel'], {
+    timeoutMs: 5000,
+    stdio: 'pipe',
+  });
+  return result.status === 0 && result.stdout.trim() ? result.stdout.trim() : candidate;
+}
+
+export function isForgeAdopted(repoRoot: string): boolean {
+  return existsSync(join(repoRoot, '.ai', 'harness', 'policy.json')) || existsSync(join(repoRoot, 'tasks', 'current.md'));
+}
+
+export function currentGitBranch(repoRoot: string): string | null {
+  const result = runProcess('git', ['-C', repoRoot, 'branch', '--show-current'], {
+    timeoutMs: 5000,
+    stdio: 'pipe',
+  });
+  return result.status === 0 && result.stdout.trim() ? result.stdout.trim() : null;
+}

package/adapters/mcp/runtime-gateway/artifact-adapter.ts

@@ -0,0 +1,52 @@
+import type { CallToolResult } from '../../../packages/protocols/mcp/tool-contract';
+import type { MultiRepositoryMcpToolContext } from '../multi-repository';
+import { writeControllerTaskLedgerArtifacts } from '../../../src/cli/controller/task-ledger';
+import { prepareTransferArtifacts } from '../../../src/cli/repositories/selected-path-actions';
+import {
+  buildReviewArtifactIndex,
+  ensureReviewArtifactRoots,
+  prepareBrowserReviewPacket,
+  prepareIosReviewPacket,
+} from '../../../src/runtime/safe-tooling';
+import { result } from './result-adapter';
+import { selected } from './shared-adapter';
+
+/** Transport-only compatibility adapter for review/transfer artifacts. */
+export function callArtifactAdapter(
+  ctx: MultiRepositoryMcpToolContext,
+  name: string,
+  args: Record<string, unknown>,
+): CallToolResult | undefined {
+  switch (name) {
+    case 'prepare_transfer_artifacts': {
+      const repository = selected(ctx, args);
+      const transfer = prepareTransferArtifacts(repository, { reason: args.reason });
+      const taskLedger = writeControllerTaskLedgerArtifacts(repository.canonicalRoot, { reason: args.reason });
+      return result({
+        repoId: repository.repoId,
+        checkoutId: repository.activeCheckoutId,
+        ...transfer,
+        taskLedger: taskLedger.projection,
+        artifacts: [...transfer.artifacts, ...taskLedger.artifacts],
+      });
+    }
+    case 'review_artifacts_prepare': {
+      const repository = selected(ctx, args);
+      return result(ensureReviewArtifactRoots(repository));
+    }
+    case 'review_artifacts_index': {
+      const repository = selected(ctx, args);
+      return result(buildReviewArtifactIndex(repository, { limit: args.limit }) as unknown as Record<string, unknown>);
+    }
+    case 'browser_review_packet': {
+      const repository = selected(ctx, args);
+      return result(prepareBrowserReviewPacket(repository, { limit: args.limit }) as unknown as Record<string, unknown>);
+    }
+    case 'ios_review_packet': {
+      const repository = selected(ctx, args);
+      return result(prepareIosReviewPacket(repository, { limit: args.limit }) as unknown as Record<string, unknown>);
+    }
+    default:
+      return undefined;
+  }
+}