@aion0/forge 0.10.67 → 0.10.68

package/RELEASE_NOTES.md

@@ -1,8 +1,8 @@
-# Forge v0.10.67
+# Forge v0.10.68
 
 Released: 2026-06-10
 
-## Changes since v0.10.66
+## Changes since v0.10.67
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.66...v0.10.67
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.67...v0.10.68

package/components/ScheduleCreateModal.tsx

@@ -148,6 +148,9 @@ export default function ScheduleCreateModal({ onClose, onCreated, existing }: Pr
       ? String(existing.action_config?.body_template ?? '{body_output}')
       : '{body_output}'
   );
+  const [emailTransport, setEmailTransport] = useState<'smtp' | 'owa'>(
+    existing?.action_kind === 'email' && existing.action_config?.transport === 'owa' ? 'owa' : 'smtp'
+  );
   const [telegramChatId, setTelegramChatId] = useState(
     existing?.action_kind === 'telegram' ? String(existing.action_config?.chat_id ?? '') : ''
   );
@@ -340,6 +343,7 @@ export default function ScheduleCreateModal({ onClose, onCreated, existing }: Pr
         action_config.to = to.length > 1 ? to : (to[0] || '');
         if (emailSubjectTpl) action_config.subject_template = emailSubjectTpl;
         if (emailBodyTpl) action_config.body_template = emailBodyTpl;
+        action_config.transport = emailTransport;
       } else if (actionKind === 'telegram') {
         if (telegramChatId.trim()) action_config.chat_id = telegramChatId.trim();
         if (telegramPrefix) action_config.prefix = telegramPrefix;
@@ -437,6 +441,7 @@ export default function ScheduleCreateModal({ onClose, onCreated, existing }: Pr
               emailTo={emailTo} onEmailTo={setEmailTo}
               emailSubjectTpl={emailSubjectTpl} onEmailSubjectTpl={setEmailSubjectTpl}
               emailBodyTpl={emailBodyTpl} onEmailBodyTpl={setEmailBodyTpl}
+              emailTransport={emailTransport} onEmailTransport={setEmailTransport}
               telegramChatId={telegramChatId} onTelegramChatId={setTelegramChatId}
               telegramPrefix={telegramPrefix} onTelegramPrefix={setTelegramPrefix}
             />
@@ -855,6 +860,7 @@ function Step3({
   emailTo, onEmailTo,
   emailSubjectTpl, onEmailSubjectTpl,
   emailBodyTpl, onEmailBodyTpl,
+  emailTransport, onEmailTransport,
   telegramChatId, onTelegramChatId,
   telegramPrefix, onTelegramPrefix,
 }: {
@@ -871,6 +877,7 @@ function Step3({
   emailTo: string; onEmailTo: (v: string) => void;
   emailSubjectTpl: string; onEmailSubjectTpl: (v: string) => void;
   emailBodyTpl: string; onEmailBodyTpl: (v: string) => void;
+  emailTransport: 'smtp' | 'owa'; onEmailTransport: (v: 'smtp' | 'owa') => void;
   telegramChatId: string; onTelegramChatId: (v: string) => void;
   telegramPrefix: string; onTelegramPrefix: (v: string) => void;
 }) {
@@ -962,7 +969,7 @@ function Step3({
         )}
         <label className="flex items-center gap-2 cursor-pointer">
           <input type="radio" name="action" checked={actionKind === 'email'} onChange={() => onActionKind('email')} />
-          <span className="text-[11px] w-44">Send Email (SMTP)</span>
+          <span className="text-[11px] w-44">Send Email</span>
           <input
             type="text"
             value={emailTo}
@@ -974,6 +981,20 @@ function Step3({
         </label>
         {actionKind === 'email' && (
           <>
+            <label className="flex items-center gap-2">
+              <span className="text-[11px] w-44 ml-6">transport</span>
+              <select
+                value={emailTransport}
+                onChange={(e) => onEmailTransport(e.target.value as 'smtp' | 'owa')}
+                className="text-[11px] px-2 py-0.5 border border-[var(--border)] rounded bg-[var(--bg-secondary)]"
+              >
+                <option value="smtp">SMTP (Settings → SMTP)</option>
+                <option value="owa">OWA connector (your mailbox, no SMTP)</option>
+              </select>
+              {emailTransport === 'owa' && (
+                <span className="text-[10px] text-[var(--text-secondary)]">needs the browser extension connected</span>
+              )}
+            </label>
             <label className="flex items-center gap-2">
               <span className="text-[11px] w-44 ml-6">subject template</span>
               <input

package/lib/help-docs/07-projects.md

@@ -4,6 +4,37 @@
 
 Add project directories in Settings → **Project Roots** (e.g. `~/Projects`). Forge scans subdirectories automatically.
 
+## How a project is resolved (pipelines / MR review / bug fix)
+
+When a pipeline (or chat-dispatched MR review / bug fix) needs a project, Forge
+resolves the given name in this order — first hit wins:
+
+1. **Exact project name** — a scanned project whose directory name equals the
+   value passed in.
+2. **Git repo match** — when the value looks like an `owner/repo` path (e.g.
+   derived from a GitLab MR URL), Forge compares it against each project's
+   **git `origin` remote**, which it auto-detects from `.git/config` during the
+   scan (no subprocess). Full path first, then the repo basename. This is how
+   "review this MR" finds the right local checkout even when the directory is
+   named differently — you don't need to type the project. Only an
+   **unambiguous single match** is accepted; if two local clones share the same
+   origin, Forge skips this step rather than guess.
+3. **Fuzzy name** — basename / `owner-repo` variants of the value.
+4. **Auto-clone** — if a GitLab connector is configured, clone the repo into
+   `<dataDir>/cloned-projects/<owner>-<repo>/` and reuse it next time.
+5. **Scratch** — the always-writable `<dataDir>/scratch` fallback for flows
+   that don't need a real checkout.
+
+Notes:
+- The detected repo is internal (not shown in Settings) — it's derived live
+  from each project's git origin on every scan, so existing projects work with
+  no migration.
+- Override detection (rare: wrong/missing origin) via
+  `settings.projectRepos: { "<projectPath>": "owner/repo" }`.
+- Auto-cloned repos under `cloned-projects/` are swept after
+  `clonedProjectKeepDays` (default 30) of disuse, unless a running pipeline
+  still has a worktree there.
+
 ## Features
 
 ### Code Tab

package/lib/init.ts

@@ -220,7 +220,7 @@ export function ensureInitialized() {
   // expired (failed/cancelled past retention). Interval from settings,
   // clamped to >= 1h to avoid runaway IO. Runs in background only.
   try {
-    const { gcPipelineTmp } = require('./pipeline-gc');
+    const { gcPipelineTmp, gcClonedProjects } = require('./pipeline-gc');
     const { loadSettings: ls } = require('./settings');
     const hours = Math.max(1, Number(ls().pipelineTmpGcIntervalHours) || 6);
     setInterval(() => {
@@ -228,6 +228,11 @@ export function ensureInitialized() {
         const r = gcPipelineTmp();
         if (r.removed.length) console.log(`[pipeline-gc] swept ${r.removed.length}/${r.scanned} dir(s)`);
       } catch (e) { console.warn('[pipeline-gc] sweep failed:', (e as Error).message); }
+      // Also sweep the auto-clone cache (long retention; conservative).
+      try {
+        const c = gcClonedProjects();
+        if (c.removed.length) console.log(`[pipeline-gc] swept ${c.removed.length}/${c.scanned} cloned repo(s)`);
+      } catch (e) { console.warn('[pipeline-gc] cloned-projects sweep failed:', (e as Error).message); }
     }, hours * 60 * 60 * 1000);
   } catch (e) { console.warn('[pipeline-gc] setup failed:', (e as Error).message); }
 

package/lib/pipeline-gc.ts

@@ -24,6 +24,7 @@ import { scanProjects, getProjectWorktreeRoot } from './projects';
 import { join } from 'node:path';
 import { getPipeline } from './pipeline';
 import { loadSettings } from './settings';
+import { getDataDir } from './dirs';
 
 export interface GcResult {
   scanned: number;
@@ -106,3 +107,64 @@ export function gcPipelineTmp(opts: { dryRun?: boolean } = {}): GcResult {
 
   return { scanned, removed, kept };
 }
+
+/**
+ * GC the auto-cloned repo cache at <dataDir>/cloned-projects/<owner>-<repo>/.
+ * These are full git clones Forge makes when a pipeline runs without a local
+ * project (resolveOrCloneProject). They're reused across runs, so we keep
+ * them a long time and only sweep ones untouched for clonedProjectKeepDays
+ * (default 30). Conservative on purpose:
+ *   - default 30d, and 0/negative disables the sweep entirely;
+ *   - never deletes a clone that still has a worktree for a non-terminal
+ *     (running/started) pipeline under it.
+ * Uses the newest mtime across the repo dir + its .forge/worktrees so an
+ * actively-used clone (recent worktree) is never considered stale.
+ */
+export function gcClonedProjects(opts: { dryRun?: boolean } = {}): GcResult {
+  const settings = loadSettings();
+  const keepDays = (settings as { clonedProjectKeepDays?: number }).clonedProjectKeepDays ?? 30;
+  const removed: GcResult['removed'] = [];
+  const kept: GcResult['kept'] = [];
+  let scanned = 0;
+  if (!keepDays || keepDays <= 0) return { scanned, removed, kept }; // disabled
+
+  const keepMs = keepDays * 86400_000;
+  const now = Date.now();
+  const root = join(getDataDir(), 'cloned-projects');
+  let entries: string[];
+  try { entries = readdirSync(root); } catch { return { scanned, removed, kept }; }
+
+  for (const entry of entries) {
+    const repoDir = join(root, entry);
+    let st: ReturnType<typeof statSync>;
+    try { st = statSync(repoDir); } catch { continue; }
+    if (!st.isDirectory()) continue;
+    scanned++;
+
+    // Newest signal across the repo dir + its worktree root.
+    let newest = st.mtimeMs;
+    const wtRoot = join(repoDir, '.forge', 'worktrees');
+    let liveWorktree = false;
+    try {
+      for (const wt of readdirSync(wtRoot)) {
+        const wtPath = join(wtRoot, wt);
+        try { newest = Math.max(newest, statSync(wtPath).mtimeMs); } catch {}
+        if (wt.startsWith('pipeline-')) {
+          const p = getPipeline(wt.slice('pipeline-'.length));
+          if (p && p.status !== 'done' && p.status !== 'failed' && p.status !== 'cancelled') {
+            liveWorktree = true;
+          }
+        }
+      }
+    } catch { /* no worktrees dir */ }
+
+    if (liveWorktree) { kept.push({ path: repoDir, reason: 'in-use (running pipeline worktree)' }); continue; }
+    if (now - newest > keepMs) {
+      if (!opts.dryRun) { try { rmSync(repoDir, { recursive: true, force: true }); } catch {} }
+      removed.push({ path: repoDir, reason: `clone unused >${keepDays}d` });
+    } else {
+      kept.push({ path: repoDir, reason: 'fresh' });
+    }
+  }
+  return { scanned, removed, kept };
+}

package/lib/pipeline.ts

@@ -11,7 +11,7 @@ import { execSync } from 'node:child_process';
 import { join } from 'node:path';
 import YAML from 'yaml';
 import { createTask, getTask, onTaskEvent, taskModelOverrides, taskAppendSystemPromptOverrides, cancelTask } from './task-manager';
-import { getProjectInfo, resolveOrCloneProject, getProjectWorktreeRoot } from './projects';
+import { getProjectInfo, resolveOrCloneProject, getProjectWorktreeRoot, ensureScratchProject } from './projects';
 import { loadSettings } from './settings';
 import { getAgent, listAgents } from './agents';
 import type { Task } from '../src/types';
@@ -747,16 +747,22 @@ export function resolveTemplate(template: string, ctx: {
 // ─── Per-run scratch dir (`{{run.tmp_dir}}`) ────────────────
 
 /**
- * Compute the absolute scratch-dir path for a pipeline run. Returns
- * empty string if input.project doesn't resolve. Does NOT mkdir.
+ * Compute the absolute scratch-dir path for a pipeline run. Falls back to
+ * the scratch project's worktree root when input.project is missing or
+ * unresolvable — NEVER returns '' (an empty {{run.tmp_dir}} made YAML like
+ * `mkdir -p {{run.tmp_dir}}/mr-${IID}` resolve to `/mr-NNN`, i.e. the
+ * read-only filesystem root — that was the "mkdir: /mr-14949: Read-only
+ * file system" crash). Does NOT mkdir.
  */
 function computePipelineTmpDir(pipeline: Pipeline): string {
   const name = pipeline.input?.project;
-  if (!name) return '';
-  const proj = getProjectInfo(name);
-  if (!proj) return '';
-  // Worktree root differs for scratch vs real projects — see getProjectWorktreeRoot.
-  return join(getProjectWorktreeRoot(proj), `pipeline-${pipeline.id}`);
+  const proj = name ? getProjectInfo(name) : null;
+  if (proj) {
+    // Worktree root differs for scratch vs real projects — see getProjectWorktreeRoot.
+    return join(getProjectWorktreeRoot(proj), `pipeline-${pipeline.id}`);
+  }
+  // No / unresolved project → writable scratch base under <dataDir>/scratch.
+  return join(ensureScratchProject(), 'worktrees', `pipeline-${pipeline.id}`);
 }
 
 /**
@@ -764,6 +770,21 @@ function computePipelineTmpDir(pipeline: Pipeline): string {
  * non-fatal — `tmpDir` stays unset and `{{run.tmp_dir}}` renders empty.
  */
 function ensurePipelineTmpDir(pipeline: Pipeline): void {
+  // Align run.tmp_dir with the project the nodes will actually use. When no
+  // project was given, resolve it through the same three-tier path the nodes
+  // use (existing → gitlab clone → scratch) and write the concrete name back
+  // to input.project, so tmp_dir lands inside that (possibly cloned) repo and
+  // downstream resolveOrCloneProject finds it as 'existing' (no double clone).
+  // Every node already calls resolveOrCloneProject, so this adds no NEW clone
+  // — it just happens once up front. Never throws (falls back to scratch).
+  if (!pipeline.input?.project) {
+    try {
+      const r = resolveOrCloneProject('');
+      if (r?.project?.name) {
+        pipeline.input = { ...(pipeline.input || {}), project: r.project.name };
+      }
+    } catch { /* leave empty → computePipelineTmpDir's scratch fallback */ }
+  }
   const dir = computePipelineTmpDir(pipeline);
   if (!dir) return;
   try {

package/lib/projects.ts

@@ -13,6 +13,46 @@ export interface LocalProject {
   hasClaudeMd: boolean;
   language: string | null;
   lastModified: string;
+  /** Normalized "owner/repo" derived from the git origin remote (or a
+   *  settings.projectRepos override). Lets MR/bug pipelines map a repo
+   *  path back to this local checkout. Undefined when not a git repo /
+   *  no origin. */
+  repo?: string;
+}
+
+/** Normalize a git remote URL to an "owner/repo" path (lowercased), so it
+ *  can be matched against a gitlab MR path. Handles ssh + https forms:
+ *    git@host:owner/repo.git        → owner/repo
+ *    https://host/owner/repo.git    → owner/repo
+ *    https://host/group/sub/repo    → group/sub/repo
+ *  Returns '' if it can't parse one. */
+function normalizeRepoPath(url: string): string {
+  let s = (url || '').trim();
+  if (!s) return '';
+  s = s.replace(/\.git$/i, '');
+  // scp-style: git@host:owner/repo
+  const scp = s.match(/^[^@]+@[^:]+:(.+)$/);
+  if (scp) return scp[1].replace(/^\/+|\/+$/g, '').toLowerCase();
+  // url-style: scheme://[user@]host/owner/repo
+  const m = s.match(/^[a-z][a-z0-9+.-]*:\/\/[^/]+\/(.+)$/i);
+  if (m) return m[1].replace(/^\/+|\/+$/g, '').toLowerCase();
+  return '';
+}
+
+/** Read a project's origin remote from .git/config WITHOUT spawning git
+ *  (scanProjects runs often; a subprocess per project would be costly).
+ *  Returns the normalized "owner/repo" or '' . */
+function readGitOriginRepo(projectPath: string): string {
+  try {
+    const cfg = readFileSync(join(projectPath, '.git', 'config'), 'utf-8');
+    // Find the [remote "origin"] section then its `url = ...` line.
+    const sec = cfg.match(/\[remote "origin"\]([\s\S]*?)(?:\n\[|$)/);
+    if (!sec) return '';
+    const u = sec[1].match(/^\s*url\s*=\s*(.+)\s*$/m);
+    return u ? normalizeRepoPath(u[1]) : '';
+  } catch {
+    return '';
+  }
 }
 
 /** Reserved name for the synthetic "scratch" project that lives under
@@ -112,6 +152,13 @@ export function scanProjects(): LocalProject[] {
         const language = detectLanguage(projectPath);
         const stat = statSync(projectPath);
 
+        // repo: manual settings.projectRepos override wins; else auto-detect
+        // from the git origin remote. Cheap (file read, no subprocess).
+        const repoOverride = (settings.projectRepos || {})[projectPath];
+        const repo = (typeof repoOverride === 'string' && repoOverride.trim())
+          ? normalizeRepoPath(repoOverride) || repoOverride.trim().toLowerCase()
+          : (hasGit ? readGitOriginRepo(projectPath) : '');
+
         projects.push({
           name: entry.name,
           path: projectPath,
@@ -120,6 +167,7 @@ export function scanProjects(): LocalProject[] {
           hasClaudeMd,
           language,
           lastModified: stat.mtime.toISOString(),
+          repo: repo || undefined,
         });
       } catch {
         // Skip inaccessible directories
@@ -301,6 +349,34 @@ export function resolveOrCloneProject(name: string | undefined): ResolveResult {
   if (trimmed) {
     const hit = getProjectInfo(trimmed);
     if (hit) return { project: hit, source: 'existing' };
+
+    const projects = scanProjects();
+
+    // Repo match (best signal): when the caller passes an "owner/repo" path
+    // (e.g. derived from an MR URL), match it against each project's git
+    // origin remote (LocalProject.repo, auto-detected in scanProjects).
+    // This is how "review this MR" finds the right local checkout without
+    // the user naming the project. Compares full path then basename; only
+    // an UNAMBIGUOUS single match wins.
+    if (trimmed.includes('/')) {
+      const want = normalizeRepoPath(trimmed) || trimmed.toLowerCase().replace(/^\/+|\/+$/g, '');
+      const wantBase = want.split('/').pop()!;
+      const byRepo = projects.filter((p) => p.repo && p.repo === want);
+      if (byRepo.length === 1) return { project: byRepo[0], source: 'existing' };
+      const byRepoBase = projects.filter((p) => p.repo && p.repo.split('/').pop() === wantBase);
+      if (byRepoBase.length === 1) return { project: byRepoBase[0], source: 'existing' };
+    }
+
+    // Fuzzy name match across the configured project roots before cloning:
+    // the caller may pass a gitlab path ("owner/repo") or the cloned-projects
+    // dir name ("owner-repo") while the local checkout is just "repo". Try
+    // the basename and the owner-repo form; only accept an UNAMBIGUOUS
+    // single match so we never silently pick the wrong repo.
+    const base = trimmed.split('/').pop()!.trim();
+    const ownerRepo = trimmed.replace(/\//g, '-');
+    const cands = projects.filter((p) =>
+      p.name === base || p.name === ownerRepo || p.name.toLowerCase() === base.toLowerCase());
+    if (cands.length === 1) return { project: cands[0], source: 'existing' };
   }
 
   // Fallback to gitlab connector when no local match. Two cases worth

package/lib/schedules/action-runner.ts

@@ -155,9 +155,6 @@ async function runChatAction(schedule: Schedule, run: ScheduleRun, output: strin
  */
 async function runEmailAction(schedule: Schedule, _run: ScheduleRun, output: string): Promise<void> {
   const settings = loadSettings();
-  if (!settings.smtpHost) {
-    throw new Error('SMTP not configured (Settings → SMTP)');
-  }
   const cfg = schedule.action_config || {};
   const toRaw = cfg.to;
   const to = Array.isArray(toRaw)
@@ -178,6 +175,30 @@ async function runEmailAction(schedule: Schedule, _run: ScheduleRun, output: str
   const bodyText = bodyTpl.replace('{date}', today).replace('{body_output}', output);
   const asHtml = !!cfg.html;
 
+  // Transport: 'smtp' (default, nodemailer) or 'owa' (send via the OWA
+  // browser connector through the extension bridge — no SMTP server needed,
+  // rides the user's logged-in mailbox; requires the extension connected,
+  // same as any browser connector in a scheduled run).
+  const emailTransport = String(cfg.transport || 'smtp').toLowerCase();
+  if (emailTransport === 'owa') {
+    const { dispatchTool } = await import('../chat/tool-dispatcher');
+    const r = await dispatchTool({
+      id: `sched-email-${Date.now()}`,
+      name: 'owa.send_mail',
+      input: { to: to.join(', '), subject, body: bodyText, body_html: asHtml },
+    });
+    let parsed: any = r.content;
+    try { parsed = JSON.parse(r.content); } catch { /* keep string */ }
+    if (r.is_error || (parsed && parsed.error)) {
+      throw new Error(`OWA send failed: ${(parsed && parsed.error) || r.content}`);
+    }
+    return;
+  }
+
+  if (!settings.smtpHost) {
+    throw new Error("SMTP not configured (Settings → SMTP). For mailbox send without SMTP, set action_config.transport='owa'.");
+  }
+
   // Lazy import keeps the SMTP client out of the main bundle until the
   // first email action actually fires.
   const nodemailer = (await import('nodemailer')).default;

package/lib/settings.ts

@@ -93,6 +93,11 @@ export interface McpServerConfig {
 
 export interface Settings {
   projectRoots: string[];
+  /** Optional per-project repo override: { <projectPath>: "owner/repo" }.
+   *  Normally the repo is auto-detected from the project's git origin remote
+   *  (see lib/projects.ts); this only overrides when detection is wrong or
+   *  the checkout has no origin. */
+  projectRepos?: Record<string, string>;
   docRoots: string[];
   claudePath: string;
   // claudeHome removed in 0.10.10 — was a never-UI-exposed override that

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.10.67",
+  "version": "0.10.68",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {