aegis-desktop 0.8.20 → 0.8.21

package/lib/local/tools.js

@@ -70,6 +70,25 @@ try {
 
 const OUTPUT_CAP = 30_000; // chars fed back to the model per tool result
 
+/**
+ * What every path argument accepts, stated ONCE so the ten schemas below cannot
+ * drift from each other or from what normalizeArgs actually does.
+ *
+ * It names the platform requirement explicitly because the failure it prevents
+ * was a model guessing posix on a Windows host (see client/platform.js
+ * resolvePath): `/home/you/Desktop/x.txt` there is drive-relative, so the write
+ * SUCCEEDED at `C:\home\you\Desktop\x.txt` and the user found nothing on their
+ * Desktop. The schema is the first place to say so — a refusal after the fact
+ * costs the model a round, a correct description costs it nothing.
+ */
+const PATH_ARG_DESC =
+  'Absolute path in THIS machine\'s own form (the Environment block names the platform and home ' +
+  'directory — a win32 host needs C:\\Users\\you\\file.txt, never /home/you/file.txt), or "~" / ' +
+  '"~/…" for the home directory. A relative path resolves against the working directory.';
+
+/** `<what>. <the path rules>` — the shape every path argument's description takes. */
+const pathDesc = (what) => `${what}. ${PATH_ARG_DESC}`;
+
 // The dialect probe (Phase 30.3), from the same module the session lives in: a
 // one-shot `exec` must run the command in a shell that was PROBED to speak the
 // dialect the command is written in, never in an unprobed `$SHELL`. Lives next
@@ -111,11 +130,11 @@ const fail = (error) => ({ ok: false, error: cap(error) });
 const SCHEMAS = {
   readFile: {
     name: 'readFile',
-    description: 'Read a file. Absolute path. Returns line-numbered content.',
+    description: 'Read a file. Returns line-numbered content.',
     parameters: {
       type: 'object',
       properties: {
-        file_path: { type: 'string', description: 'Absolute path' },
+        file_path: { type: 'string', description: pathDesc('The file to read') },
         offset: { type: 'number', description: 'Start line (0-based)' },
         limit: { type: 'number', description: `The number of lines to read (max 10000, default ${READ_LINE_CAP})` },
       },
@@ -130,7 +149,7 @@ const SCHEMAS = {
     parameters: {
       type: 'object',
       properties: {
-        file_path: { type: 'string', description: 'Absolute path' },
+        file_path: { type: 'string', description: pathDesc('The file to write') },
         content: { type: 'string', description: 'Full file contents' },
       },
       required: ['file_path', 'content'],
@@ -145,7 +164,7 @@ const SCHEMAS = {
     parameters: {
       type: 'object',
       properties: {
-        file_path: { type: 'string', description: 'Absolute path' },
+        file_path: { type: 'string', description: pathDesc('The file to edit') },
         old_string: { type: 'string', description: 'Text to replace; must be unique unless replace_all' },
         new_string: { type: 'string', description: 'Replacement text' },
         replace_all: { type: 'boolean', description: 'Replace every occurrence' },
@@ -160,7 +179,7 @@ const SCHEMAS = {
     parameters: {
       type: 'object',
       properties: {
-        path: { type: 'string', description: 'The directory to list (default: the working directory)' },
+        path: { type: 'string', description: pathDesc('The directory to list (default: the working directory)') },
       },
       required: [],
       additionalProperties: false,
@@ -174,7 +193,7 @@ const SCHEMAS = {
       type: 'object',
       properties: {
         pattern: { type: 'string', description: 'Glob, e.g. "**/*.test.js"' },
-        path: { type: 'string', description: 'Search root (default: cwd)' },
+        path: { type: 'string', description: pathDesc('Search root (default: the working directory)') },
       },
       required: ['pattern'],
       additionalProperties: false,
@@ -187,7 +206,7 @@ const SCHEMAS = {
       type: 'object',
       properties: {
         pattern: { type: 'string', description: 'The regular expression to search for' },
-        path: { type: 'string', description: 'The directory to search in (default: the working directory)' },
+        path: { type: 'string', description: pathDesc('The directory to search in (default: the working directory)') },
       },
       required: ['pattern'],
       additionalProperties: false,
@@ -202,7 +221,7 @@ const SCHEMAS = {
       type: 'object',
       properties: {
         command: { type: 'string', description: 'Command to run' },
-        cwd: { type: 'string', description: 'Run this one command elsewhere; session cwd unchanged' },
+        cwd: { type: 'string', description: pathDesc('Run this one command elsewhere; session cwd unchanged') },
         timeout: { type: 'number', description: `Timeout in milliseconds (max ${EXEC_TIMEOUT_CAP}, default ${EXEC_TIMEOUT_DEFAULT})` },
         description: { type: 'string', description: 'A brief description of what the command does (for display)' },
       },
@@ -221,7 +240,7 @@ const SCHEMAS = {
       type: 'object',
       properties: {
         sub: { type: 'string', enum: ['status', 'list'], description: 'status (default) or the full config listing' },
-        cwd: { type: 'string', description: 'Repo to inspect (default: the working directory)' },
+        cwd: { type: 'string', description: pathDesc('Repo to inspect (default: the working directory)') },
       },
       required: [],
       additionalProperties: false,
@@ -237,7 +256,7 @@ const SCHEMAS = {
     parameters: {
       type: 'object',
       properties: {
-        cwd: { type: 'string', description: 'Repo to install into (default: the working directory)' },
+        cwd: { type: 'string', description: pathDesc('Repo to install into (default: the working directory)') },
         dry_run: { type: 'boolean', description: 'Print the commands instead of running them' },
       },
       required: [],
@@ -301,6 +320,85 @@ function toolsFor({ includeSubagent = true } = {}) {
   return openaiTools({ includeSubagent });
 }
 
+// ── Path normalisation ──────────────────────────────────────────────────────
+
+/**
+ * Which argument of each tool is a path on this machine. `task` has none (its
+ * argument is a prompt), and `exec`'s `command` is deliberately absent: a shell
+ * command is not a path and its contents are the shell's business, not ours.
+ */
+const TOOL_PATH_ARGS = Object.freeze({
+  readFile: ['file_path'],
+  writeFile: ['file_path'],
+  editFile: ['file_path'],
+  listDir: ['path'],
+  glob: ['path'],
+  grep: ['path'],
+  exec: ['cwd'],
+  hooks: ['cwd'],
+  installHooks: ['cwd'],
+});
+
+/**
+ * Resolve every path argument of one tool call against THIS machine, returning
+ * `{ ok, args, error }` — `args` is a copy with each path replaced by its real
+ * absolute form, and a single refusal fails the whole call.
+ *
+ * Three reasons this is one function applied to the call, rather than a
+ * `resolvePath` sprinkled through each executor:
+ *
+ *   1. The GUARDS read the path too. tools/agent-gate.mjs does
+ *      `path.resolve(cwd, args.file_path)` to decide whether the target sits in
+ *      an agent-gated tree, and engine.js's covenant check inspects `args`
+ *      before anything runs. A `~/…` reaching them unexpanded means they rule on
+ *      `<cwd>/~/…` — a different file than the one that would be written. The
+ *      only way the guard and the write can agree is for the path to be real
+ *      BEFORE either looks at it.
+ *   2. The approval gate shows a diff for one path and then writes to another
+ *      otherwise: previewMutation and applyChecked must resolve identically, and
+ *      sharing this function is what makes that true by construction.
+ *   3. An absent or empty argument is left ALONE, so each executor keeps its own
+ *      "required" error and its own default (listDir with no `path` still means
+ *      the working directory). Normalising only what was actually supplied is
+ *      what keeps this a path fix and not a behaviour change.
+ *
+ * Idempotent, because resolvePath is: engine.js normalises early for the guards
+ * and executeTool normalises again for a direct caller, and the second pass is a
+ * no-op rather than a second resolution.
+ */
+function normalizeArgs(name, args, ctx = {}) {
+  const input = args && typeof args === 'object' ? args : {};
+  const keys = TOOL_PATH_ARGS[name];
+  if (!keys) return { ok: true, args: input, error: null };
+
+  let out = input;
+  for (const key of keys) {
+    const value = input[key];
+    if (typeof value !== 'string' || !value.trim()) continue; // absent → the executor's default
+    const res = platform.resolvePath(value, { cwd: ctx && ctx.cwd ? ctx.cwd : undefined });
+    if (!res.ok) return { ok: false, args: input, error: `${name}: ${key} — ${res.error}` };
+    if (res.path !== value) {
+      if (out === input) out = { ...input };
+      out[key] = res.path;
+    }
+  }
+  return { ok: true, args: out, error: null };
+}
+
+/**
+ * The directory a tool with no explicit `path` works in: this TURN's working
+ * directory, not the host process's.
+ *
+ * `process.cwd()` is wrong here and was visibly wrong off Linux: the Electron
+ * main process inherits whatever the OS launched the app from — `/` from a .desktop
+ * entry, `C:\Program Files\AEGIS Desktop` from a Windows shortcut — so a bare
+ * `listDir`/`glob`/`grep` searched the install directory instead of the user's
+ * repo. It stays the fallback for a direct call that supplies no ctx.
+ */
+function baseDir(ctx) {
+  return (ctx && typeof ctx.cwd === 'string' && ctx.cwd) || process.cwd();
+}
+
 // ── Executors ───────────────────────────────────────────────────────────────
 
 function readFile({ file_path, offset = 0, limit } = {}) {
@@ -538,9 +636,11 @@ function previewEditFile({ file_path, old_string, new_string, replace_all } = {}
 
 /** Dispatch a preview by tool name. Only writeFile/editFile have one — exec
  *  has nothing to diff, and the approval gate skips this call for it. */
-function previewMutation(name, args) {
-  if (name === 'writeFile') return previewWriteFile(args);
-  if (name === 'editFile') return previewEditFile(args);
+function previewMutation(name, args, ctx = {}) {
+  const norm = normalizeArgs(name, args, ctx);
+  if (!norm.ok) return { ok: false, error: norm.error };
+  if (name === 'writeFile') return previewWriteFile(norm.args);
+  if (name === 'editFile') return previewEditFile(norm.args);
   return { ok: false, error: `no diff preview for ${name}` };
 }
 
@@ -591,16 +691,18 @@ function applyEditChecked({ file_path, after } = {}, expectedHash) {
 /** Apply an approved writeFile/editFile call using the hash captured in its
  *  `preview` (see previewMutation) — the single entry point engine.js calls
  *  once the user has said yes. */
-function applyChecked(name, args, preview) {
-  if (name === 'writeFile') return applyWriteChecked(args, preview.hash);
-  return applyEditChecked({ file_path: args.file_path, after: preview.after }, preview.hash);
+function applyChecked(name, args, preview, ctx = {}) {
+  const norm = normalizeArgs(name, args, ctx);
+  if (!norm.ok) return fail(norm.error);
+  if (name === 'writeFile') return applyWriteChecked(norm.args, preview.hash);
+  return applyEditChecked({ file_path: norm.args.file_path, after: preview.after }, preview.hash);
 }
 
 const IGNORED_DIRS = new Set(['node_modules', '.git', 'dist', '.aegiscode']);
 
-function listDir({ path: dir } = {}) {
+function listDir({ path: dir } = {}, ctx = {}) {
   try {
-    const base = dir || process.cwd();
+    const base = dir || baseDir(ctx);
     const entries = fs.readdirSync(base, { withFileTypes: true });
     const rows = entries
       .filter((e) => !IGNORED_DIRS.has(e.name))
@@ -645,10 +747,10 @@ function walk(dir, fn, depth = 0) {
   }
 }
 
-function glob({ pattern, path: root } = {}) {
+function glob({ pattern, path: root } = {}, ctx = {}) {
   try {
     if (!pattern) return fail('pattern is required');
-    const base = root || process.cwd();
+    const base = root || baseDir(ctx);
     const re = globToRegex(String(pattern));
     const hits = [];
     walk(base, (full) => {
@@ -662,11 +764,11 @@ function glob({ pattern, path: root } = {}) {
   }
 }
 
-function grep({ pattern, path: root } = {}) {
+function grep({ pattern, path: root } = {}, ctx = {}) {
   try {
     if (!pattern) return fail('pattern is required');
     const re = new RegExp(pattern);
-    const base = root || process.cwd();
+    const base = root || baseDir(ctx);
     const hits = [];
     walk(base, (full) => {
       if (hits.length >= MATCH_CAP) return;
@@ -990,7 +1092,12 @@ function nearestManifest(start) {
 
 async function executeTool(name, args, ctx) {
   if (!isTool(name)) return fail(`unknown tool "${name}" (known: ${toolNames().join(', ')})`);
-  const input = args && typeof args === 'object' ? args : {};
+  // Paths become real BEFORE the agent-key gate below resolves them itself —
+  // see normalizeArgs. A `~/…` that reached the gate unexpanded was ruled on as
+  // `<cwd>/~/…`, i.e. a different file than the one about to be written.
+  const norm = normalizeArgs(name, args, ctx || {});
+  if (!norm.ok) return fail(norm.error);
+  const input = norm.args;
   // ── agent-key gate (tools/agent-gate.mjs) ──────────────────────────────
   // The in-process half of the lock whose other half is .githooks/. A tree
   // that declares .aegis/guard.json must not be mutated through this app
@@ -1060,6 +1167,10 @@ module.exports = {
   MUTATING_TOOLS,
   previewMutation,
   applyChecked,
+  // path handling (client/platform.js resolvePath applied to a tool call)
+  normalizeArgs,
+  TOOL_PATH_ARGS,
+  PATH_ARG_DESC,
   // limits (unit tests assert against them instead of hard-coding numbers)
   OUTPUT_CAP,
   READ_LINE_CAP,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aegis-desktop",
   "productName": "AEGIS Desktop",
-  "version": "0.8.20",
+  "version": "0.8.21",
   "description": "Thin Electron host for AEGIS — a local chat UI over the shared client/aegis.js transport. Ships transport + UI only; engine logic stays server-side.",
   "author": {
     "name": "AEGIS Code",