dsh-wsl-workspace 0.2.2 → 0.2.3

package/src/client/index.ts

@@ -1,194 +1,233 @@
-/**
- * Browser half of dsh-wsl-workspace. Registers the "Add WSL workspace…"
- * action beside Settings at the sidebar foot (the official
- * `sidebar.footer.action` slot), and keeps every blank session whose
- * workspace is a WSL UNC path composed from the WSL VARIANT of the mode it
- * currently runs (`standard` → `wsl-standard`, PTC → `wsl-code`, …) — so the
- * WSL execution world composes with any mode instead of being a mode itself.
- *
- * The binding is a watching effect rather than a one-shot dialog action so
- * EVERY creation path (this dialog, the workspace row's New Session, the
- * hero picker) converges on the WSL-backed composition automatically.
- */
-
-import type { ConnectionHandle } from '@deepseek-ai/dsh-api-remotes/client'
-// Type-only: pulls the locale plugin's Context merge (ctx.locale), the
-// runtime's ClientContext, and the ui-sidebar SlotMap merge (the
-// 'sidebar.footer.action' entry) into this program.
-import type {} from '@deepseek-ai/dsh-client-locale/client'
-import type {} from '@deepseek-ai/dsh-client-ui-sidebar/client'
-import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client'
-import { check as checkApi, listDir as listDirApi, listDistros as listDistrosApi, setWorkspaceUser as setWorkspaceUserApi } from './api.ts'
-import { AddWslWorkspace, type AddWslWorkspaceInjected } from './AddWslWorkspace.tsx'
-import { ensureStyles } from './styles.ts'
-import { zh, en } from './locales.ts'
-import { isWslUnc } from '../shared/paths.ts'
-
-/** Required services (cordis fiber inject). */
-export const inject = ['slots', 'locale', 'connection', 'sessions', 'workspaces']
-
-/** The legacy standalone WSL preset id (folded into the mode variants). */
-const LEGACY_WSL_PRESET_ID = 'wsl'
-
-/**
- * Minimal sessions-service face. The renderer-host ctx merge types
- * `ctx.sessions` as its own SessionStore; the service the runtime actually
- * registers under that key satisfies this narrower contract, so the cast is
- * the documented boundary for a third-party plugin.
- */
-interface WslSessionsFace {
-  list: {
-    getSnapshot(): { ids: string[]; byId: Record<string, { blank: boolean; cwd?: string; agentPreset?: string }> }
-    subscribe(fn: () => void): () => void
-  }
-  noteAgentPreset(sessionId: string, agentPreset: string): void
-}
-
-/** Minimal workspaces-service face (create + start-session only). */
-interface WslWorkspacesFace {
-  create(input: { path: string }): Promise<{ workspaceId: string }>
-  startSession(workspaceId?: string): void
-}
-
-/**
- * Mount the sidebar action and the auto-binding effect.
- * @param ctx - the browser plugin context.
- */
-export function apply(ctx: ClientContext): void {
-  const { api } = ctx.get('connection') as ConnectionHandle
-  const workspaces = ctx.get('workspaces') as unknown as WslWorkspacesFace
-  const sessions = ctx.get('sessions') as unknown as WslSessionsFace
-
-  ensureStyles()
-
-  ctx.effect(
-    () => ctx.locale.register('wslWorkspace' as never, { zh, en }),
-    'dsh-wsl-workspace: locale dictionaries',
-  )
-
-  // The injected translate function reads the live DeepSeek Harness locale,
-  // so the dialog copy follows the app language setting automatically.
-  const t = ctx.locale.bind('wslWorkspace' as never) as unknown as (key: string, params?: Record<string, unknown>) => string
-
-  const injected = (): AddWslWorkspaceInjected => ({
-    t,
-    checkPreset: async (): Promise<string | undefined> => {
-      let roster
-      try {
-        const response = await api.agentPresets.list({})
-        roster = response.result
-      } catch (error) {
-        return error instanceof Error ? error.message : String(error)
-      }
-      if (!roster.ok) return roster.error.message
-      const healthy = roster.value.presets.find((entry: { id: string; broken?: string }) =>
-        entry.id.startsWith('wsl-') && entry.broken === undefined)
-      if (healthy === undefined) return t('error.presetMissing')
-      return undefined
-    },
-    listDistros: () => listDistrosApi(),
-    listDir: (distro, path) => listDirApi(distro, path),
-    check: (distro, path) => checkApi(distro, path),
-    createWorkspace: async (path, username): Promise<string | undefined> => {
-      try {
-        const view = await workspaces.create({ path })
-        await setWorkspaceUserApi(path, username)
-        workspaces.startSession(view.workspaceId)
-        return undefined
-      } catch (error) {
-        return error instanceof Error ? error.message : String(error)
-      }
-    },
-  })
-
-  ctx.effect(
-    () => ctx.slots.inject(
-      'sidebar.footer.action',
-      () => ctx.slots.register(
-        { name: 'sidebar.footer.action', id: 'wsl-workspace', inject: injected },
-        AddWslWorkspace,
-      ),
-    ),
-    'dsh-wsl-workspace: sidebar footer action',
-  )
-
-  // Mode-variant binding: a blank session whose workspace is a WSL UNC path
-  // is recomposed to the WSL variant of the mode it currently runs — plain
-  // 标准 becomes `wsl-standard`, PTC becomes `wsl-code`, and so on — so the
-  // WSL execution world composes with ANY mode instead of replacing it. The
-  // host refuses non-blank sessions (agent-preset-locked), so the swap is
-  // attempted at most a few times per session.
-  ctx.effect(() => {
-    const inFlight = new Set<string>()
-    const attempts = new Map<string, number>()
-    const MAX_ATTEMPTS = 3
-    // Healthy `wsl-<mode>` variant ids plus the roster's default preset id
-    // (what a session with no explicit choice gets). Refreshed periodically
-    // so variants generated after this page loaded are picked up.
-    let variants = new Set<string>()
-    let defaultPreset: string | undefined
-    const refreshRoster = (): void => {
-      void api.agentPresets.list({}).then((response: {
-        result: { ok: boolean; value: { presets: { id: string; broken?: string; isDefault?: boolean }[] } }
-      }) => {
-        const result = response.result
-        if (!result.ok) return
-        variants = new Set(result.value.presets
-          .filter((entry: { id: string; broken?: string }) =>
-            entry.broken === undefined && entry.id.startsWith('wsl-'))
-          .map((entry: { id: string }) => entry.id))
-        defaultPreset = result.value.presets.find(
-          (entry: { id: string; isDefault?: boolean }) => entry.isDefault === true,
-        )?.id
-      }).catch(() => {
-        // A failed roster read leaves the previous mapping; sessions stay on
-        // their current composition until the next refresh.
-      })
-    }
-    refreshRoster()
-    const maybeBind = (): void => {
-      const state = sessions.list.getSnapshot()
-      for (const id of state.ids) {
-        const summary = state.byId[id]
-        if (summary === undefined || !summary.blank || summary.cwd === undefined) continue
-        if (!isWslUnc(summary.cwd)) continue
-        const current = summary.agentPreset
-        if (current !== undefined && current.startsWith('wsl-')) continue
-        // Legacy standalone `wsl` (now folded into the variants): remap it to
-        // the default mode's variant, since the standalone preset no longer
-        // exists in the roster.
-        const base = current === LEGACY_WSL_PRESET_ID
-          ? (defaultPreset ?? 'standard')
-          : (current ?? defaultPreset)
-        if (base === undefined || base === LEGACY_WSL_PRESET_ID || base.startsWith('wsl-')) continue
-        const target = `wsl-${base.toLowerCase()}`
-        if (!variants.has(target)) continue
-        if (inFlight.has(id) || (attempts.get(id) ?? 0) >= MAX_ATTEMPTS) continue
-        inFlight.add(id)
-        void api.agentPresets.select({ sessionId: id, agentPreset: target })
-          .then((response: { result: { ok: boolean } }) => {
-            if (response.result.ok) sessions.noteAgentPreset(id, target)
-          })
-          .catch(() => {
-            // A refused or aborted swap (session already produced output,
-            // roster churn, reconnect) leaves the session on its current
-            // composition; count the attempt so a stuck session stops
-            // retrying after MAX_ATTEMPTS.
-            attempts.set(id, (attempts.get(id) ?? 0) + 1)
-          })
-          .finally(() => {
-            inFlight.delete(id)
-          })
-      }
-    }
-    maybeBind()
-    const unsubscribe = sessions.list.subscribe(() => maybeBind())
-    // Variants are generated at host boot; a page loaded before that would
-    // never see them without a periodic refresh.
-    const timer = window.setInterval(refreshRoster, 60_000)
-    return () => {
-      unsubscribe()
-      window.clearInterval(timer)
-    }
-  }, 'dsh-wsl-workspace: WSL mode-variant binding')
-}
+/**
+ * Browser half of dsh-wsl-workspace. Registers the "Add WSL workspace…"
+ * action beside Settings at the sidebar foot (the official
+ * `sidebar.footer.action` slot), and keeps every blank session whose
+ * workspace is a WSL UNC path composed from the WSL VARIANT of the mode it
+ * currently runs (`standard` → `wsl-standard`, PTC → `wsl-code`, …) — so the
+ * WSL execution world composes with any mode instead of being a mode itself.
+ *
+ * The binding is a watching effect rather than a one-shot dialog action so
+ * EVERY creation path (this dialog, the workspace row's New Session, the
+ * hero picker) converges on the WSL-backed composition automatically.
+ */
+
+import type { ConnectionHandle } from '@deepseek-ai/dsh-api-remotes/client'
+// Type-only: pulls the locale plugin's Context merge (ctx.locale), the
+// runtime's ClientContext, and the ui-sidebar SlotMap merge (the
+// 'sidebar.footer.action' entry) into this program.
+import type {} from '@deepseek-ai/dsh-client-locale/client'
+import type {} from '@deepseek-ai/dsh-client-ui-sidebar/client'
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client'
+import { check as checkApi, listDir as listDirApi, listDistros as listDistrosApi, listWorkspaces as listWorkspacesApi, registerWindows as registerWindowsApi, setWorkspaceUser as setWorkspaceUserApi } from './api.ts'
+import { AddWslWorkspace, type AddWslWorkspaceInjected } from './AddWslWorkspace.tsx'
+import { ensureStyles } from './styles.ts'
+import { zh, en } from './locales.ts'
+import { canonicalWindowsPath, isWslUnc, joinUnc, mntToWindowsPath } from '../shared/paths.ts'
+
+/** Required services (cordis fiber inject). */
+export const inject = ['slots', 'locale', 'connection', 'sessions', 'workspaces']
+
+/** The legacy standalone WSL preset id (folded into the mode variants). */
+const LEGACY_WSL_PRESET_ID = 'wsl'
+
+/**
+ * Minimal sessions-service face. The renderer-host ctx merge types
+ * `ctx.sessions` as its own SessionStore; the service the runtime actually
+ * registers under that key satisfies this narrower contract, so the cast is
+ * the documented boundary for a third-party plugin.
+ */
+interface WslSessionsFace {
+  list: {
+    getSnapshot(): { ids: string[]; byId: Record<string, { blank: boolean; cwd?: string; agentPreset?: string }> }
+    subscribe(fn: () => void): () => void
+  }
+  noteAgentPreset(sessionId: string, agentPreset: string): void
+}
+
+/** Minimal workspaces-service face (create + start-session only). */
+interface WslWorkspacesFace {
+  create(input: { path: string }): Promise<{ workspaceId: string }>
+  startSession(workspaceId?: string): void
+}
+
+/**
+ * Mount the sidebar action and the auto-binding effect.
+ * @param ctx - the browser plugin context.
+ */
+export function apply(ctx: ClientContext): void {
+  const { api } = ctx.get('connection') as ConnectionHandle
+  const workspaces = ctx.get('workspaces') as unknown as WslWorkspacesFace
+  const sessions = ctx.get('sessions') as unknown as WslSessionsFace
+
+  ensureStyles()
+
+  ctx.effect(
+    () => ctx.locale.register('wslWorkspace' as never, { zh, en }),
+    'dsh-wsl-workspace: locale dictionaries',
+  )
+
+  // The injected translate function reads the live DeepSeek Harness locale,
+  // so the dialog copy follows the app language setting automatically.
+  const t = ctx.locale.bind('wslWorkspace' as never) as unknown as (key: string, params?: Record<string, unknown>) => string
+
+  // Canonical Windows drive keys of every registered `/mnt/<drive>` workspace
+  // (refreshed from the host store; see refreshRoster). A blank session whose
+  // cwd is one of these binds to the WSL variant like a UNC-cwd session.
+  let wslWindowsPaths = new Set<string>()
+
+  const injected = (): AddWslWorkspaceInjected => ({
+    t,
+    checkPreset: async (): Promise<string | undefined> => {
+      let roster
+      try {
+        const response = await api.agentPresets.list({})
+        roster = response.result
+      } catch (error) {
+        return error instanceof Error ? error.message : String(error)
+      }
+      if (!roster.ok) return roster.error.message
+      const healthy = roster.value.presets.find((entry: { id: string; broken?: string }) =>
+        entry.id.startsWith('wsl-') && entry.broken === undefined)
+      if (healthy === undefined) return t('error.presetMissing')
+      return undefined
+    },
+    listDistros: () => listDistrosApi(),
+    listDir: (distro, path) => listDirApi(distro, path),
+    check: (distro, path) => checkApi(distro, path),
+    createWorkspace: async (linuxPath, username, distro): Promise<string | undefined> => {
+      try {
+        const winPath = mntToWindowsPath(linuxPath)
+        if (winPath !== null) {
+          // `/mnt/<drive>` workspace: the workspace registry realpath/stats
+          // the path and 9P cannot serve drvfs mounts, so register under the
+          // drive spelling and store distro/username for the session env.
+          // The browser binding below recognizes the drive cwd as WSL.
+          const view = await workspaces.create({ path: winPath })
+          await registerWindowsApi(linuxPath, distro, username)
+          const canonical = canonicalWindowsPath(winPath)
+          if (canonical !== null) wslWindowsPaths = new Set(wslWindowsPaths).add(canonical)
+          workspaces.startSession(view.workspaceId)
+          return undefined
+        }
+        const uncPath = joinUnc(distro, linuxPath)
+        const view = await workspaces.create({ path: uncPath })
+        await setWorkspaceUserApi(uncPath, username)
+        workspaces.startSession(view.workspaceId)
+        return undefined
+      } catch (error) {
+        return error instanceof Error ? error.message : String(error)
+      }
+    },
+  })
+
+  ctx.effect(
+    () => ctx.slots.inject(
+      'sidebar.footer.action',
+      () => ctx.slots.register(
+        { name: 'sidebar.footer.action', id: 'wsl-workspace', inject: injected },
+        AddWslWorkspace,
+      ),
+    ),
+    'dsh-wsl-workspace: sidebar footer action',
+  )
+
+  // Mode-variant binding: a blank session whose workspace is a WSL UNC path
+  // is recomposed to the WSL variant of the mode it currently runs — plain
+  // 标准 becomes `wsl-standard`, PTC becomes `wsl-code`, and so on — so the
+  // WSL execution world composes with ANY mode instead of replacing it. The
+  // host refuses non-blank sessions (agent-preset-locked), so the swap is
+  // attempted at most a few times per session.
+  ctx.effect(() => {
+    const inFlight = new Set<string>()
+    const attempts = new Map<string, number>()
+    const MAX_ATTEMPTS = 3
+    // Healthy `wsl-<mode>` variant ids plus the roster's default preset id
+    // (what a session with no explicit choice gets). Refreshed periodically
+    // so variants generated after this page loaded are picked up.
+    let variants = new Set<string>()
+    let defaultPreset: string | undefined
+    const refreshRoster = (): void => {
+      void api.agentPresets.list({}).then((response: {
+        result: { ok: boolean; value: { presets: { id: string; broken?: string; isDefault?: boolean }[] } }
+      }) => {
+        const result = response.result
+        if (!result.ok) return
+        variants = new Set(result.value.presets
+          .filter((entry: { id: string; broken?: string }) =>
+            entry.broken === undefined && entry.id.startsWith('wsl-'))
+          .map((entry: { id: string }) => entry.id))
+        defaultPreset = result.value.presets.find(
+          (entry: { id: string; isDefault?: boolean }) => entry.isDefault === true,
+        )?.id
+      }).catch(() => {
+        // A failed roster read leaves the previous mapping; sessions stay on
+        // their current composition until the next refresh.
+      })
+    }
+    refreshRoster()
+    const refreshWorkspaces = (): void => {
+      void listWorkspacesApi().then((keys: string[]) => {
+        const next = new Set<string>()
+        for (const key of keys) {
+          const canonical = canonicalWindowsPath(key)
+          if (canonical !== null) next.add(canonical)
+        }
+        wslWindowsPaths = next
+      }).catch(() => {
+        // A failed store read leaves the previous set; sessions stay on
+        // their current composition until the next refresh.
+      })
+    }
+    refreshWorkspaces()
+    const maybeBind = (): void => {
+      const state = sessions.list.getSnapshot()
+      for (const id of state.ids) {
+        const summary = state.byId[id]
+        if (summary === undefined || !summary.blank || summary.cwd === undefined) continue
+        // A session belongs to the WSL world when its cwd is a WSL UNC path,
+        // or a Windows drive path registered as a `/mnt/<drive>` workspace
+        // (9P cannot serve drvfs, so those workspaces carry drive cwds).
+        const canonical = canonicalWindowsPath(summary.cwd)
+        const isWsl = isWslUnc(summary.cwd)
+          || (canonical !== null && wslWindowsPaths.has(canonical))
+        if (!isWsl) continue
+        const current = summary.agentPreset
+        if (current !== undefined && current.startsWith('wsl-')) continue
+        // Legacy standalone `wsl` (now folded into the variants): remap it to
+        // the default mode's variant, since the standalone preset no longer
+        // exists in the roster.
+        const base = current === LEGACY_WSL_PRESET_ID
+          ? (defaultPreset ?? 'standard')
+          : (current ?? defaultPreset)
+        if (base === undefined || base === LEGACY_WSL_PRESET_ID || base.startsWith('wsl-')) continue
+        const target = `wsl-${base.toLowerCase()}`
+        if (!variants.has(target)) continue
+        if (inFlight.has(id) || (attempts.get(id) ?? 0) >= MAX_ATTEMPTS) continue
+        inFlight.add(id)
+        void api.agentPresets.select({ sessionId: id, agentPreset: target })
+          .then((response: { result: { ok: boolean } }) => {
+            if (response.result.ok) sessions.noteAgentPreset(id, target)
+          })
+          .catch(() => {
+            // A refused or aborted swap (session already produced output,
+            // roster churn, reconnect) leaves the session on its current
+            // composition; count the attempt so a stuck session stops
+            // retrying after MAX_ATTEMPTS.
+            attempts.set(id, (attempts.get(id) ?? 0) + 1)
+          })
+          .finally(() => {
+            inFlight.delete(id)
+          })
+      }
+    }
+    maybeBind()
+    const unsubscribe = sessions.list.subscribe(() => maybeBind())
+    // Variants are generated at host boot; a page loaded before that would
+    // never see them without a periodic refresh.
+    const timer = window.setInterval(refreshRoster, 60_000)
+    return () => {
+      unsubscribe()
+      window.clearInterval(timer)
+    }
+  }, 'dsh-wsl-workspace: WSL mode-variant binding')
+}

package/src/index.ts

@@ -25,13 +25,13 @@
 
 import { Context } from '@deepseek-ai/cordis'
 import z from '@deepseek-ai/schemastery'
-import { mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { dirname, join } from 'node:path'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import { homedir } from 'node:os'
-import { joinUnc, normalizeLinuxPath, isAbsoluteLinuxPath, isValidWslUsername, parseWslUnc } from './shared/paths.ts'
-import { canonicalWslUnc, getWorkspaceUsername, setWorkspaceUsername } from './shared/wsl-credentials.ts'
+import { joinUnc, mntToWindowsPath, normalizeLinuxPath, isAbsoluteLinuxPath, isValidWslUsername, parseWslUnc } from './shared/paths.ts'
+import { canonicalWslUnc, getWindowsWorkspace, getWorkspaceUsername, listWorkspaceKeys, registerWindowsWorkspace, setWorkspaceUsername } from './shared/wsl-credentials.ts'
 import { defaultDistro, listDistros } from './shared/wsl.ts'
 import { isWslVariantId, transformPresetForWsl, variantIdFor } from './host/variants.ts'
 
@@ -213,10 +213,29 @@ function requireWslUnc(value: unknown): string {
   return canonical
 }
 
-/** Resolve one directory listing over the 9P share. */
+/**
+ * Resolve one directory listing for the dialog. The 9P share (`\\wsl.localhost\…`)
+ * serves only the ext4 volume: `/mnt/<drive>` (drvfs) reads return Access
+ * denied, so drvfs paths are read through their Windows drive spelling and
+ * `/mnt` itself is synthesized from the drives present on the host.
+ */
 function listWslDir(distro: string, linuxPath: string): WslDirListingWire {
-  const unc = joinUnc(distro, linuxPath)
-  const dirents = readdirSync(unc, { withFileTypes: true })
+  if (linuxPath === '/mnt') {
+    const entries: WslDirEntryWire[] = []
+    for (let i = 0; i < 26; i++) {
+      const letter = String.fromCharCode(65 + i)
+      try {
+        const info = statSync(`${letter}:\\`)
+        if (info.isDirectory()) entries.push({ name: letter.toLowerCase(), kind: 'directory' })
+      } catch {
+        // Absent drive: skip.
+      }
+    }
+    return { path: '/mnt', parent: '/', entries }
+  }
+  const winPath = mntToWindowsPath(linuxPath)
+  const readPath = winPath !== null ? winPath : joinUnc(distro, linuxPath)
+  const dirents = readdirSync(readPath, { withFileTypes: true })
   const entries: WslDirEntryWire[] = dirents
     .slice(0, 1000)
     .map((dirent): WslDirEntryWire => {
@@ -253,14 +272,33 @@ async function dispatch(method: string, params: Record<string, unknown>): Promis
     case 'check': {
       const distro = requireDistro(params.distro)
       const path = requireLinuxPath(params.path, 'path')
-      const unc = joinUnc(distro, path)
+      // drvfs paths (Access denied over 9P) are checked through their drive spelling.
+      const winPath = mntToWindowsPath(path)
+      const readPath = winPath !== null ? winPath : joinUnc(distro, path)
       try {
-        const info = statSync(unc)
+        const info = statSync(readPath)
         return { exists: true, isDirectory: info.isDirectory() }
       } catch {
         return { exists: false, isDirectory: false }
       }
     }
+    case 'registerWindows': {
+      // A `/mnt/<drive>` workspace registers under its Windows drive path
+      // (the registry realpath/stats it, and 9P cannot serve drvfs) with the
+      // distro stored for the per-session env contributor.
+      const distro = requireDistro(params.distro)
+      const linuxPath = requireLinuxPath(params.linuxPath, 'path')
+      const winPath = mntToWindowsPath(linuxPath)
+      if (winPath === null) throw new Error('registerWindows requires a /mnt/<drive> Linux path')
+      const username = typeof params.username === 'string' ? params.username : undefined
+      registerWindowsWorkspace(winPath, distro, username)
+      return null
+    }
+    case 'listWorkspaces': {
+      // Every registered WSL workspace key (UNC and Windows drive spellings):
+      // the client uses the drive keys to recognize `/mnt` workspaces.
+      return listWorkspaceKeys()
+    }
     case 'setUser': {
       const path = requireWslUnc(params.path)
       const username = params.username
@@ -296,6 +334,21 @@ interface AgentPresetsService {
  * @param shellPath - absolute path of the plugin's built WSL shell provider.
  * @param fsPath - absolute path of the plugin's built WSL fs provider.
  */
+/**
+ * Relative './x.mjs' row files a composition references. Local function-plugin
+ * rows travel with their preset directory; generated variants must copy them
+ * along or the variant composition fails to load.
+ * @param composition - the composition text.
+ */
+function localRowFiles(composition: string): Set<string> {
+  const files = new Set<string>()
+  for (const line of composition.split('\n')) {
+    const match = /^\s*name:\s*['"]?(\.\/[^'"]+\.m?js)['"]?\s*$/.exec(line)
+    if (match?.[1] !== undefined) files.add(match[1])
+  }
+  return files
+}
+
 async function materializeVariants(
   agentPresets: AgentPresetsService,
   dshHome: string,
@@ -314,6 +367,35 @@ async function materializeVariants(
     const dir = join(userRoot, variantId)
     mkdirSync(dir, { recursive: true })
     writeFileSync(join(dir, 'agent.cordis.yml'), transformed, 'utf8')
+    // Copy local function-plugin row files (name: './x.mjs') from the source
+    // preset into the variant directory, including their transitive relative
+    // imports — the variant composition references them relatively and they
+    // must travel with it, or the variant fails to load at mount time.
+    const pending = [...localRowFiles(transformed)]
+    const visited = new Set<string>()
+    while (pending.length > 0) {
+      const rowFile = pending.pop()
+      if (rowFile === undefined || visited.has(rowFile)) continue
+      visited.add(rowFile)
+      const srcFile = join(dirname(preset.path), rowFile)
+      if (!existsSync(srcFile)) continue
+      mkdirSync(dirname(join(dir, rowFile)), { recursive: true })
+      copyFileSync(srcFile, join(dir, rowFile))
+      try {
+        const content = readFileSync(srcFile, 'utf8')
+        const importRe = /(?:from\s+|import\s*\(\s*|require\s*\(\s*)['"](\.\/[^'"]+)['"]/g
+        let match: RegExpExecArray | null
+        while ((match = importRe.exec(content)) !== null) {
+          let spec = match[1]
+          if (spec === undefined) continue
+          if (!/\.m?js$/.test(spec)) spec += '.mjs'
+          pending.push(spec)
+        }
+      } catch {
+        // Unreadable row file: keep whatever was copied; the variant reports
+        // the failure through the roster when mounted.
+      }
+    }
     const labels = MODE_DISPLAY_LABELS[preset.id]
     let name = variantName(preset.id, preset.id)
     let orderLine = ''
@@ -410,11 +492,24 @@ export function apply(ctx: Context, config: Config): void {
       resolve(execution) {
         const cwd = execution.agent?.session.header.cwd
         const unc = cwd === undefined ? null : parseWslUnc(cwd)
-        if (unc === null) return {}
-        const username = getWorkspaceUsername(joinUnc(unc.distro, unc.linuxPath))
-        return username === undefined || username === ''
-          ? { DSH_WSL_DISTRO: unc.distro }
-          : { DSH_WSL_DISTRO: unc.distro, DSH_WSL_USER: username }
+        if (unc !== null) {
+          const username = getWorkspaceUsername(joinUnc(unc.distro, unc.linuxPath))
+          return username === undefined || username === ''
+            ? { DSH_WSL_DISTRO: unc.distro }
+            : { DSH_WSL_DISTRO: unc.distro, DSH_WSL_USER: username }
+        }
+        // A Windows-drive cwd belongs to a `/mnt/<drive>` WSL workspace (9P
+        // cannot serve drvfs, so those register under their drive path): the
+        // stored distro drives `wsl.exe -d` for bash.
+        if (cwd !== undefined && /^[A-Za-z]:[\\/]/.test(cwd)) {
+          const entry = getWindowsWorkspace(cwd)
+          if (entry !== undefined && entry.distro !== undefined && entry.distro !== '') {
+            return entry.username === undefined || entry.username === ''
+              ? { DSH_WSL_DISTRO: entry.distro }
+              : { DSH_WSL_DISTRO: entry.distro, DSH_WSL_USER: entry.username }
+          }
+        }
+        return {}
       },
     }), 'dsh-wsl-workspace: per-session distro env fact')
   }