@yeaft/webchat-agent 0.1.1014 → 0.1.1015

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.1014",
+  "version": "0.1.1015",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/yeaft/engine.js

@@ -21,6 +21,7 @@ import { randomUUID } from 'crypto';
 import { promises as fsp } from 'fs';
 import { join, resolve as resolvePath } from 'path';
 import { buildSystemPrompt, buildWorkerPrompt } from './prompts.js';
+import { getRuntimePlatformInfo } from './runtime-platform.js';
 import { LLMContextError, LLMAbortError } from './llm/adapter.js';
 import { runMemoryPreflow, buildRelevantScopes } from './sessions/pre-flow.js';
 import { readProjectDoc, pickProjectDocFile, DEFAULT_PROJECT_DOC_MAX_BYTES } from './sessions/project-doc.js';
@@ -815,6 +816,7 @@ export class Engine {
       activeScope,
       sessionAnnouncement,
       projectDoc,
+      runtimePlatform: getRuntimePlatformInfo(),
       taskCtx,
       // Worker-shape harness is descriptive metadata for human inspection;
       // production prompts skip it to save tokens. Re-enable via env when
@@ -903,6 +905,7 @@ export class Engine {
     return {
       signal,
       yeaftDir: this.#yeaftDir,
+      runtimePlatform: getRuntimePlatformInfo(),
       // Group-scoped working directory. Threaded from #runQuery({ workDir })
       // → set by web-bridge runVpTurn from sessionMeta.workDir. Tools read
       // `ctx.cwd` and resolve relative paths against it. Always absolute

package/yeaft/prompts.js

@@ -25,6 +25,7 @@
 import { readFileSync, existsSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { getRuntimePlatformInfo, renderRuntimePlatformPrompt } from './runtime-platform.js';
 import { DEFAULT_VPS } from './vp/seed-defaults.js';
 
 // ─── Template Loading (one-time at startup) ──────────────────────
@@ -307,6 +308,7 @@ export function buildSystemPrompt({
   vpPersona,
   sessionAnnouncement = '',
   projectDoc = '',
+  runtimePlatform,
 } = {}) {
   // Normalize app locales like `zh-CN` to prompt dictionary/template keys.
   const effectiveLang = normalizePromptLanguage(language);
@@ -370,7 +372,12 @@ export function buildSystemPrompt({
     parts.push(dreamTemplate || lang.dream);
   }
 
-  // ─── 4. Tools + Tool Guidance ──────────────────────────
+  // ─── 4. Runtime Platform + Tools + Tool Guidance ──────
+  const runtimePlatformBlock = renderRuntimePlatformPrompt(runtimePlatform || getRuntimePlatformInfo(), effectiveLang);
+  if (runtimePlatformBlock) {
+    parts.push(runtimePlatformBlock);
+  }
+
   if (toolNames.length > 0) {
     parts.push(lang.tools(toolNames.join(', ')));
 

package/yeaft/runtime-platform.js

@@ -0,0 +1,103 @@
+/**
+ * runtime-platform.js — Runtime OS/platform facts for prompts and tools.
+ *
+ * Keep OS detection in one place. Tools should read `ctx.runtimePlatform`
+ * instead of guessing from scattered `process.platform` checks.
+ */
+
+const WINDOWS_PLATFORMS = new Set(['win32']);
+const MAC_PLATFORMS = new Set(['darwin']);
+const LINUX_PLATFORMS = new Set(['linux']);
+
+/**
+ * @param {string | undefined | null} platform
+ * @returns {NodeJS.Platform | string}
+ */
+export function normalizePlatform(platform) {
+  const raw = typeof platform === 'string' && platform.trim()
+    ? platform.trim().toLowerCase()
+    : process.platform;
+  if (raw === 'windows') return 'win32';
+  if (raw === 'mac' || raw === 'macos' || raw === 'osx') return 'darwin';
+  return raw;
+}
+
+/**
+ * @param {{ platform?: string, env?: NodeJS.ProcessEnv }} [opts]
+ * @returns {{ command: string, argsPrefix: string[], family: 'powershell' | 'cmd' | 'posix' }}
+ */
+export function resolveDefaultShell(opts = {}) {
+  const platform = normalizePlatform(opts.platform);
+  const env = opts.env || process.env;
+
+  if (WINDOWS_PLATFORMS.has(platform)) {
+    const configured = env.YEAFT_WINDOWS_SHELL || env.PWSH || env.POWERSHELL;
+    const shell = configured || 'powershell.exe';
+    const lower = shell.toLowerCase();
+    if (lower.includes('cmd.exe') || lower.endsWith('cmd')) {
+      return { command: shell, argsPrefix: ['/d', '/s', '/c'], family: 'cmd' };
+    }
+    return {
+      command: shell,
+      argsPrefix: ['-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command'],
+      family: 'powershell',
+    };
+  }
+
+  return {
+    command: env.SHELL || '/bin/bash',
+    argsPrefix: ['-c'],
+    family: 'posix',
+  };
+}
+
+/**
+ * @param {{ platform?: string, env?: NodeJS.ProcessEnv }} [opts]
+ */
+export function getRuntimePlatformInfo(opts = {}) {
+  const platform = normalizePlatform(opts.platform);
+  const shell = resolveDefaultShell({ platform, env: opts.env });
+  const isWindows = WINDOWS_PLATFORMS.has(platform);
+  const isMacOS = MAC_PLATFORMS.has(platform);
+  const isLinux = LINUX_PLATFORMS.has(platform);
+
+  return Object.freeze({
+    platform,
+    os: isWindows ? 'Windows' : (isMacOS ? 'macOS' : (isLinux ? 'Linux' : platform)),
+    isWindows,
+    isMacOS,
+    isLinux,
+    pathSeparator: isWindows ? '\\' : '/',
+    defaultShell: shell.command,
+    shellFamily: shell.family,
+    shellArgsPrefix: shell.argsPrefix,
+  });
+}
+
+/**
+ * @param {ReturnType<typeof getRuntimePlatformInfo>} info
+ * @param {string} [language]
+ */
+export function renderRuntimePlatformPrompt(info = getRuntimePlatformInfo(), language = 'en') {
+  const shell = info.shellFamily === 'powershell'
+    ? `${info.defaultShell} (PowerShell syntax)`
+    : (info.shellFamily === 'cmd' ? `${info.defaultShell} (cmd.exe syntax)` : `${info.defaultShell} (POSIX shell syntax)`);
+
+  if ((language || '').toLowerCase().startsWith('zh')) {
+    return [
+      '## runtime_platform',
+      `当前 Agent 运行系统：${info.os} (${info.platform})`,
+      `默认命令 shell：${shell}`,
+      `路径分隔符：${info.pathSeparator}`,
+      '生成 Bash 工具命令时必须匹配当前系统；Windows 上优先使用 PowerShell/cmd 语法，不要默认输出 Linux-only 命令。',
+    ].join('\n');
+  }
+
+  return [
+    '## runtime_platform',
+    `Agent OS: ${info.os} (${info.platform})`,
+    `Default command shell: ${shell}`,
+    `Path separator: ${info.pathSeparator}`,
+    'When generating Bash tool commands, match this OS. On Windows, prefer PowerShell/cmd syntax instead of Linux-only commands.',
+  ].join('\n');
+}

package/yeaft/templates/base.md

@@ -76,16 +76,10 @@ You are participating in the current session. Keep the user's context, answer fr
 
 - 使用紧凑的 GitHub 风格 Markdown。
 - 先给结论；不要一句话一段。
-<<<<<<< HEAD
 - 列表用于并列信息，不要把每句话都拆成列表项。
-- 围栏代码块 只用于代码、命令、配置、diff 或日志，并写语言标识。
-- 文件路径用 行内代码，例如 `agent/yeaft/prompts.js`。
-=======
-- 列表用于并列信息，不要把每句话都拆成 bullet。
-- fenced code block 只用于代码、命令、配置、diff 或日志，并写语言标识。
+- 围栏代码块只用于代码、命令、配置、diff 或日志，并写语言标识。
 - 不要把普通说明、摘要、标签、标题、列表或单个词包进 fenced code block。
 - 文件路径、命令、标识符、状态值或短文本用 inline code，不要用 fenced code block。
 - 文件路径用 inline code，例如 `agent/yeaft/prompts.js`。
->>>>>>> origin/main
 - 开发总结用 `改动 / 验证 / 风险` 或等价的简洁结构。
 - 评审用 `结论 / Findings / 验证`。

package/yeaft/templates/common-rules.md

@@ -89,15 +89,10 @@
 - 使用 GitHub 风格 Markdown。
 - 普通说明写成紧凑自然段，不要一句话一段。
 - 并列信息用扁平列表，避免深层嵌套。
-<<<<<<< HEAD
 - 围栏代码块只用于真正的代码、命令、配置、diff、日志或用户需要精确复制的文本，并始终带语言标识。
-- 文件路径用行内代码，例如 `agent/yeaft/prompts.js`。
-=======
-- fenced code block 只用于真正的代码、命令、配置、diff、日志或用户需要精确复制的文本，并始终带语言标识。
 - 不要把普通说明、摘要、标签、标题、列表或单个词包进 fenced code block。
 - 文件路径、命令、标识符、状态值或短文本用 inline code，不要用 fenced code block。
 - 文件路径用 inline code，例如 `agent/yeaft/prompts.js`。
->>>>>>> origin/main
 - 开发完成汇报使用：`改动`、`验证`、`风险 / 下一步`。
 - 评审使用：`结论`、`发现项`、`验证`。
 - 排障在需要时使用：`现象`、`证据`、`修复`、`验证`；简单问题保持更短。

package/yeaft/tools/bash.js

@@ -4,13 +4,15 @@
  * Spawns a child process to run shell commands with timeout, output
  * truncation, working directory support, and cancellation via AbortSignal.
  *
- * Modeled after Claude Code's Bash tool implementation.
+ * The tool name remains Bash for wire compatibility. Internally it uses the
+ * platform default shell: POSIX shell on Linux/macOS, PowerShell/cmd on Windows.
  */
 
 import { defineTool } from './types.js';
 import { spawn } from 'child_process';
 import { existsSync } from 'fs';
 import { resolve } from 'path';
+import { getRuntimePlatformInfo, resolveDefaultShell } from '../runtime-platform.js';
 
 /** Max output size in bytes before truncation (256 KB). */
 const MAX_OUTPUT = 256 * 1024;
@@ -21,18 +23,44 @@ const DEFAULT_TIMEOUT_MS = 120_000;
 /** Max timeout in ms (10 minutes). */
 const MAX_TIMEOUT_MS = 600_000;
 
+/**
+ * @param {string} command
+ * @param {{ runtimePlatform?: object }} opts
+ */
+export function buildShellInvocation(command, opts = {}) {
+  const runtimePlatform = opts.runtimePlatform || getRuntimePlatformInfo();
+  const shell = runtimePlatform.defaultShell
+    ? {
+        command: runtimePlatform.defaultShell,
+        argsPrefix: Array.isArray(runtimePlatform.shellArgsPrefix) ? runtimePlatform.shellArgsPrefix : null,
+        family: runtimePlatform.shellFamily,
+      }
+    : resolveDefaultShell({ platform: runtimePlatform.platform });
+
+  const argsPrefix = Array.isArray(shell.argsPrefix)
+    ? shell.argsPrefix
+    : resolveDefaultShell({ platform: runtimePlatform.platform }).argsPrefix;
+
+  return {
+    command: shell.command,
+    args: [...argsPrefix, command],
+    family: shell.family || runtimePlatform.shellFamily || 'posix',
+  };
+}
+
 /**
  * Run a command in a child process.
  * @returns {Promise<{ stdout: string, stderr: string, exitCode: number, timedOut: boolean }>}
  */
-function runCommand(command, { cwd, timeout, signal }) {
-  return new Promise((resolve, reject) => {
-    const shell = process.env.SHELL || '/bin/bash';
-    const proc = spawn(shell, ['-c', command], {
+function runCommand(command, { cwd, timeout, signal, runtimePlatform }) {
+  return new Promise((resolve) => {
+    const platform = runtimePlatform || getRuntimePlatformInfo();
+    const invocation = buildShellInvocation(command, { runtimePlatform: platform });
+    const proc = spawn(invocation.command, invocation.args, {
       cwd,
       env: { ...process.env, TERM: 'dumb', FORCE_COLOR: '0' },
       stdio: ['ignore', 'pipe', 'pipe'],
-      timeout,
+      detached: !platform.isWindows,
     });
 
     let stdout = '';
@@ -40,6 +68,31 @@ function runCommand(command, { cwd, timeout, signal }) {
     let stdoutTruncated = false;
     let stderrTruncated = false;
     let timedOut = false;
+    let settled = false;
+    let timeoutId = null;
+
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      resolve(result);
+    };
+
+    const killProcess = () => {
+      try {
+        if (!platform.isWindows && proc.pid) {
+          process.kill(-proc.pid, 'SIGTERM');
+          return;
+        }
+      } catch {
+        // Fall back to killing the shell process below.
+      }
+      try {
+        proc.kill('SIGTERM');
+      } catch {
+        // ignore
+      }
+    };
 
     proc.stdout.on('data', (chunk) => {
       if (stdout.length < MAX_OUTPUT) {
@@ -61,46 +114,41 @@ function runCommand(command, { cwd, timeout, signal }) {
       }
     });
 
-    // Handle abort signal
-    const onAbort = () => {
-      try { proc.kill('SIGTERM'); } catch {}
-      setTimeout(() => {
-        try { proc.kill('SIGKILL'); } catch {}
-      }, 2000);
-    };
+    timeoutId = setTimeout(() => {
+      timedOut = true;
+      killProcess();
+      finish({
+        stdout,
+        stderr: stderr + `\nProcess timed out after ${timeout}ms`,
+        exitCode: 124,
+        timedOut: true,
+      });
+    }, timeout);
+
     if (signal) {
-      if (signal.aborted) { onAbort(); return; }
-      signal.addEventListener('abort', onAbort, { once: true });
+      signal.addEventListener('abort', () => {
+        killProcess();
+      }, { once: true });
     }
 
-    proc.on('close', (code) => {
-      if (signal) signal.removeEventListener('abort', onAbort);
-      resolve({
-        stdout: stdoutTruncated ? stdout + '\n... (output truncated)' : stdout,
-        stderr: stderrTruncated ? stderr + '\n... (stderr truncated)' : stderr,
-        exitCode: code ?? 1,
+    proc.on('close', (code, signalName) => {
+      if (stdoutTruncated) stdout += '\n[Output truncated]';
+      if (stderrTruncated) stderr += '\n[Output truncated]';
+      finish({
+        stdout,
+        stderr,
+        exitCode: timedOut ? 124 : (code ?? (signalName ? 128 : 1)),
         timedOut,
       });
     });
 
     proc.on('error', (err) => {
-      if (signal) signal.removeEventListener('abort', onAbort);
-      if (err.code === 'ETIMEDOUT' || err.killed) {
-        timedOut = true;
-        resolve({
-          stdout,
-          stderr: stderr + `\nProcess timed out after ${timeout}ms`,
-          exitCode: 124,
-          timedOut: true,
-        });
-      } else {
-        resolve({
-          stdout,
-          stderr: `Error spawning process: ${err.message}`,
-          exitCode: 1,
-          timedOut: false,
-        });
-      }
+      finish({
+        stdout,
+        stderr: `Error spawning process: ${err.message}`,
+        exitCode: 1,
+        timedOut: false,
+      });
     });
   });
 }
@@ -109,10 +157,13 @@ export default defineTool({
   name: 'Bash',
   description: `Execute a shell command and return its output.
 
-Use this tool to run CLI commands, scripts, and system operations.
+Use this tool to run CLI commands, scripts, and system operations. The tool name
+is kept as Bash for compatibility; on Windows the command is executed through
+the configured Windows shell (PowerShell by default, or cmd when configured).
 
 Guidelines:
 - Commands run in the working directory (cwd from context)
+- Match command syntax to the Agent OS shown in the runtime_platform prompt
 - Timeout defaults to 2 minutes (max 10 minutes)
 - Large outputs are truncated at 256KB
 - Use absolute paths when possible
@@ -124,7 +175,7 @@ Guidelines:
     properties: {
       command: {
         type: 'string',
-        description: 'The shell command to execute',
+        description: 'The shell command to execute using the Agent OS default shell',
       },
       cwd: {
         type: 'string',
@@ -143,8 +194,9 @@ Guidelines:
     if (!input?.command) return false;
     const cmd = input.command.toLowerCase();
     return cmd.includes('rm ') || cmd.includes('rmdir') ||
+           cmd.includes('remove-item') || cmd.startsWith('del ') || cmd.includes(' del ') ||
            cmd.includes('git reset --hard') || cmd.includes('git clean') ||
-           cmd.includes('dd ') || cmd.includes('mkfs') ||
+           cmd.includes('dd ') || cmd.includes('mkfs') || cmd.includes('format ') ||
            cmd.includes('> /dev/') || cmd.includes('chmod 000');
   },
   async execute(input, ctx) {
@@ -162,12 +214,14 @@ Guidelines:
 
     // Clamp timeout
     const timeout = Math.min(Math.max(timeout_ms || DEFAULT_TIMEOUT_MS, 1000), MAX_TIMEOUT_MS);
+    const runtimePlatform = ctx?.runtimePlatform || getRuntimePlatformInfo();
 
     try {
       const result = await runCommand(command, {
         cwd,
         timeout,
         signal: ctx?.signal,
+        runtimePlatform,
       });
 
       // Format output similar to Claude Code
@@ -176,13 +230,13 @@ Guidelines:
       if (result.stderr) parts.push(`STDERR:\n${result.stderr}`);
       if (result.timedOut) parts.push(`\n(Command timed out after ${timeout}ms)`);
 
-      const output = parts.join('\n') || '(no output)';
-
-      return result.exitCode === 0
-        ? output
-        : `Exit code: ${result.exitCode}\n${output}`;
+      const output = parts.join('\n');
+      if (result.exitCode !== 0) {
+        return `Exit code: ${result.exitCode}\n${output}`;
+      }
+      return output || '(no output)';
     } catch (err) {
-      return JSON.stringify({ error: `Bash execution failed: ${err.message}` });
+      return JSON.stringify({ error: err.message });
     }
   },
 });

package/yeaft/tools/enter-worktree.js

@@ -9,7 +9,7 @@
  */
 
 import { defineTool } from './types.js';
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { existsSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
 import { randomUUID } from 'crypto';
@@ -45,7 +45,7 @@ Returns the worktree path and branch name.`,
 
     // Verify we're in a git repo
     try {
-      execSync('git rev-parse --git-dir', { cwd, stdio: 'pipe' });
+      execFileSync('git', ['rev-parse', '--git-dir'], { cwd, stdio: 'pipe' });
     } catch {
       return JSON.stringify({ error: 'Not in a git repository' });
     }
@@ -75,9 +75,9 @@ Returns the worktree path and branch name.`,
     }
 
     try {
-      // Create worktree with new branch
-      const cmd = `git worktree add -b "${branchName}" "${worktreeDir}" ${baseRef}`;
-      execSync(cmd, { cwd, stdio: 'pipe' });
+      // Create worktree with new branch. Use execFileSync args instead of
+      // shell quoting so Windows drive letters and spaces in paths survive.
+      execFileSync('git', ['worktree', 'add', '-b', branchName, worktreeDir, baseRef], { cwd, stdio: 'pipe' });
 
       return JSON.stringify({
         success: true,

package/yeaft/tools/exit-worktree.js

@@ -8,7 +8,7 @@
  */
 
 import { defineTool } from './types.js';
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { existsSync } from 'fs';
 import { resolve } from 'path';
 
@@ -66,7 +66,7 @@ unless discard_changes is set to true.`,
       // Check for uncommitted changes
       if (!input.discard_changes) {
         try {
-          const status = execSync('git status --porcelain', {
+          const status = execFileSync('git', ['status', '--porcelain'], {
             cwd: worktreePath,
             encoding: 'utf8',
             stdio: ['pipe', 'pipe', 'pipe'],
@@ -86,7 +86,7 @@ unless discard_changes is set to true.`,
       // Get branch name before removal
       let branchName = null;
       try {
-        branchName = execSync('git rev-parse --abbrev-ref HEAD', {
+        branchName = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
           cwd: worktreePath,
           encoding: 'utf8',
           stdio: ['pipe', 'pipe', 'pipe'],
@@ -95,9 +95,9 @@ unless discard_changes is set to true.`,
         // ignore
       }
 
-      // Remove worktree
-      const forceFlag = input.discard_changes ? ' --force' : '';
-      execSync(`git worktree remove "${worktreePath}"${forceFlag}`, {
+      // Remove worktree. Use argv form so Windows paths with spaces or drive
+      // letters are passed to git unchanged.
+      execFileSync('git', ['worktree', 'remove', ...(input.discard_changes ? ['--force'] : []), worktreePath], {
         cwd: mainCwd,
         stdio: 'pipe',
       });
@@ -105,7 +105,7 @@ unless discard_changes is set to true.`,
       // Remove the branch if it was a yeaft worktree branch
       if (branchName && branchName.startsWith('yeaft-wt/')) {
         try {
-          execSync(`git branch -D "${branchName}"`, {
+          execFileSync('git', ['branch', '-D', branchName], {
             cwd: mainCwd,
             stdio: 'pipe',
           });

package/yeaft/tools/path-safety.js

@@ -0,0 +1,49 @@
+/**
+ * path-safety.js — Cross-platform path containment helpers for tools.
+ */
+
+import path from 'path';
+
+/**
+ * Return true when child is equal to or inside parent for the supplied path
+ * implementation (`path` on the host, or `path.win32`/`path.posix` in tests).
+ *
+ * @param {string} parent
+ * @param {string} child
+ * @param {{ relative: Function, isAbsolute: Function, resolve: Function }} [pathImpl]
+ */
+export function isPathInsideOrEqual(parent, child, pathImpl = path) {
+  if (!parent || !child) return false;
+  const base = pathImpl.resolve(parent);
+  const target = pathImpl.resolve(child);
+  const rel = pathImpl.relative(base, target);
+  return rel === '' || (!!rel && !rel.startsWith('..') && !pathImpl.isAbsolute(rel));
+}
+
+/**
+ * @param {string} absPath
+ * @param {string} cwd
+ * @param {string[]} [allowlist]
+ * @param {{ relative: Function, isAbsolute: Function, resolve: Function }} [pathImpl]
+ */
+export function checkPathAllowed(absPath, cwd, allowlist = [], pathImpl = path) {
+  if (isPathInsideOrEqual(cwd, absPath, pathImpl)) return null;
+
+  if (Array.isArray(allowlist)) {
+    for (const dir of allowlist) {
+      if (typeof dir !== 'string' || !pathImpl.isAbsolute(dir)) continue;
+      if (isPathInsideOrEqual(dir, absPath, pathImpl)) return null;
+    }
+  }
+
+  const inputWasAbs = pathImpl.isAbsolute(absPath);
+  return inputWasAbs
+    ? {
+        kind: 'absolute_outside_allowlist',
+        message: 'Absolute image paths must be inside the project directory or a ctx.imageAllowlist directory.',
+      }
+    : {
+        kind: 'relative_escape',
+        message: 'Relative image paths may not escape the working directory.',
+      };
+}

package/yeaft/tools/types.js

@@ -14,6 +14,8 @@
  * @typedef {Object} ToolContext
  * @property {AbortSignal} [signal] — cancellation signal
  * @property {string} [yeaftDir] — Yeaft data directory
+ * @property {ReturnType<import('../runtime-platform.js').getRuntimePlatformInfo>} [runtimePlatform]
+ *   — runtime OS/shell facts for platform-aware tools
  * @property {string} [cwd] — working directory
  * @property {import('../mcp.js').MCPManager} [mcpManager] — MCP manager
  * @property {object} [skillManager] — Skill manager

package/yeaft/tools/view-image.js

@@ -27,7 +27,8 @@
 import { defineTool } from './types.js';
 import { stat, readFile } from 'fs/promises';
 import { existsSync } from 'fs';
-import { resolve, extname, isAbsolute, relative } from 'path';
+import { resolve, extname, isAbsolute } from 'path';
+import { checkPathAllowed } from './path-safety.js';
 
 /** Default max image size in bytes (20 MiB). Override via ctx.maxImageBytes. */
 const DEFAULT_MAX_IMAGE_BYTES = 20 * 1024 * 1024;
@@ -109,36 +110,6 @@ function parseImageDimensions(buffer, ext) {
   return null;
 }
 
-/**
- * Check whether `absPath` is allowed given a project `cwd` and an optional
- * allowlist of absolute directories. Returns `null` on success, or an object
- * `{ kind, message }` describing the failure. The `kind` field lets callers
- * tailor the error text (see prev-3 P2: distinguish "absolute path outside
- * project" from "relative path containing ..").
- */
-function checkPathAllowed(absPath, cwd, allowlist) {
-  // Reject if the resolved path lives inside the project (good).
-  const relToCwd = relative(cwd, absPath);
-  const insideCwd = relToCwd && !relToCwd.startsWith('..') && !isAbsolute(relToCwd);
-  if (insideCwd) return null;
-
-  // Otherwise must match an allowlist entry.
-  if (Array.isArray(allowlist) && allowlist.length > 0) {
-    for (const dir of allowlist) {
-      if (typeof dir !== 'string' || !isAbsolute(dir)) continue;
-      const rel = relative(dir, absPath);
-      if (rel && !rel.startsWith('..') && !isAbsolute(rel)) return null;
-    }
-  }
-
-  return {
-    kind: 'path_outside',
-    message:
-      'Path is outside the project directory and not on the image allowlist. ' +
-      'Either move the file into the project, or ask the user to add its parent ' +
-      'directory to ctx.imageAllowlist (set via ~/.yeaft/config.json imageAllowlist[]).',
-  };
-}
 
 function formatBytes(n) {
   if (n < 1024) return `${n}B`;