dsh-wsl-workspace 0.1.0

package/src/client/api.ts

@@ -0,0 +1,104 @@
+/**
+ * Thin fetch client for the Host plugin route. The browser calls
+ * POST /wsl-workspace/api with a `{ method, params }` envelope and the Host
+ * answers `{ ok: true, value }` or `{ ok: false, error }`.
+ */
+
+/** Relative route the Host half registers (same-origin with the web server). */
+const ENDPOINT = '/wsl-workspace/api'
+
+/** One directory entry as the Host lists it. */
+export interface WslDirEntry {
+  name: string
+  kind: 'directory' | 'file' | 'other'
+}
+
+/** One directory level plus its breadcrumb ancestry. */
+export interface WslDirListing {
+  /** The listed absolute Linux path. */
+  path: string
+  /** Parent Linux path, or null at the filesystem root. */
+  parent: string | null
+  /** The level's children (in name order; the client filters to directories). */
+  entries: WslDirEntry[]
+}
+
+/** Existence/directory check result for one Linux path. */
+export interface WslPathCheck {
+  exists: boolean
+  isDirectory: boolean
+}
+
+/** Wire envelope the Host route answers with. */
+type Envelope<T> = { ok: true; value: T } | { ok: false; error: string }
+
+/** Human text for an unknown rejection, reusing the repository's idiom. */
+function errorMessage(value: unknown): string {
+  return value instanceof Error ? value.message : String(value)
+}
+
+/**
+ * Perform one POST call and unwrap the envelope.
+ * @param method - the Host method name.
+ * @param params - the method payload.
+ * @returns the unwrapped value, or throws an Error on network or `ok:false`.
+ */
+async function call<T>(method: string, params: Record<string, unknown> = {}): Promise<T> {
+  let response: Response
+  try {
+    response = await fetch(ENDPOINT, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ method, params }),
+    })
+  } catch (error) {
+    // The transport refused before answering (offline, origin mismatch, 404).
+    throw new Error(`wsl-workspace request failed: ${errorMessage(error)}`)
+  }
+  let envelope: Envelope<T>
+  try {
+    envelope = (await response.json()) as Envelope<T>
+  } catch {
+    // A non-JSON body means a proxy/loader answered instead of the Host route.
+    throw new Error(`wsl-workspace answered non-JSON (${response.status})`)
+  }
+  if (!envelope.ok) throw new Error(envelope.error)
+  return envelope.value
+}
+
+/**
+ * List the WSL distros installed on the host.
+ * @returns distro names in registry order.
+ */
+export async function listDistros(): Promise<string[]> {
+  return call<string[]>('listDistros', {})
+}
+
+/**
+ * List one directory level inside a distro.
+ * @param distro - distro name.
+ * @param path - absolute Linux directory to list.
+ * @returns the level's listing with ancestry.
+ */
+export async function listDir(distro: string, path: string): Promise<WslDirListing> {
+  return call<WslDirListing>('listDir', { distro, path })
+}
+
+/**
+ * Check whether a Linux path exists and is a directory.
+ * @param distro - distro name.
+ * @param path - absolute Linux path.
+ * @returns existence and directory facts.
+ */
+export async function check(distro: string, path: string): Promise<WslPathCheck> {
+  return call<WslPathCheck>('check', { distro, path })
+}
+
+/**
+ * Store (or clear, with an empty string) the username of one WSL workspace.
+ * @param path - the workspace UNC path.
+ * @param username - the Linux username; empty string clears the stored value.
+ */
+export async function setWorkspaceUser(path: string, username: string): Promise<void> {
+  return call<void>('setUser', { path, username })
+}

package/src/client/index.ts

@@ -0,0 +1,193 @@
+/**
+ * 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 locale preference.
+  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')
+}

package/src/client/locales.ts

@@ -0,0 +1,68 @@
+/**
+ * Bilingual dictionaries for the `wslWorkspace` locale namespace. Product copy
+ * is Chinese; English is the parallel export for the standalone bundle.
+ */
+
+/**
+ * The `wslWorkspace` translations (Chinese, the primary product copy).
+ */
+export const zh: Record<string, string> = {
+  'action.add': 'WSL 工作区',
+  'action.title': '添加 WSL 工作区…',
+
+  'dialog.title': '添加 WSL 工作区',
+  'dialog.distro': '发行版',
+  'dialog.path': '路径',
+  'dialog.pathPlaceholder': '/home/',
+  'dialog.username': '用户名',
+  'dialog.usernamePlaceholder': '留空则使用发行版默认用户',
+  'dialog.loading': '正在加载…',
+  'dialog.browseEmpty': '此目录没有子文件夹',
+  'dialog.upLevel': '..（返回上级）',
+  'dialog.browse': '浏览',
+  'dialog.check': '检查',
+  'dialog.confirm': '创建并打开',
+  'dialog.cancel': '取消',
+  'dialog.retry': '重试',
+
+  'error.loadDistros': '无法获取 WSL 发行版列表，请确认已安装 WSL 且插件宿主端可用',
+  'error.rateLimited': '操作过于频繁，请稍后重试',
+  'error.loadDir': '无法浏览该目录',
+  'error.presetMissing': '未找到健康的 wsl preset，请确认插件宿主端已安装并配置该 preset',
+  'error.invalidPath': '请输入以 / 开头的 Linux 绝对路径',
+  'error.invalidUsername': '用户名无效：需以字母或下划线开头，仅含字母、数字、_、.、-',
+  'error.pathNotFound': '该路径不存在或是文件，请选择一个文件夹',
+  'error.createFailed': '创建工作区失败',
+}
+
+/**
+ * The `wslWorkspace` translations (English).
+ */
+export const en: Record<string, string> = {
+  'action.add': 'WSL Workspace',
+  'action.title': 'Add WSL workspace…',
+
+  'dialog.title': 'Add WSL workspace',
+  'dialog.distro': 'Distro',
+  'dialog.path': 'Path',
+  'dialog.pathPlaceholder': '/home/',
+  'dialog.username': 'Username',
+  'dialog.usernamePlaceholder': 'Leave empty to use the distro default user',
+  'dialog.loading': 'Loading…',
+  'dialog.browseEmpty': 'No subdirectories here',
+  'dialog.upLevel': '.. (up)',
+  'dialog.browse': 'Browse',
+  'dialog.check': 'Check',
+  'dialog.confirm': 'Create & open',
+  'dialog.cancel': 'Cancel',
+  'dialog.retry': 'Retry',
+
+  'error.loadDistros': 'Could not list WSL distros; confirm WSL is installed and the plugin host side is reachable',
+  'error.rateLimited': 'Too many attempts; retry in a moment',
+  'error.loadDir': 'Could not browse this directory',
+  'error.presetMissing': 'No healthy "wsl" preset found; confirm the plugin host side installed and configured it',
+  'error.invalidPath': 'Enter an absolute Linux path starting with /',
+  'error.invalidUsername': 'Invalid username: start with a letter or underscore; only letters, digits, _ . -',
+  'error.pathNotFound': 'The path does not exist or is a file; choose a folder',
+  'error.createFailed': 'Failed to create the workspace',
+}

package/src/client/styles.ts

@@ -0,0 +1,282 @@
+/**
+ * Third-party stylesheet injection for the WSL workspace UI (the plugin
+ * builds no CSS bundle, so styles are injected as one idempotent `<style>`).
+ * Colors derive exclusively from the `--dsw-*` design tokens.
+ */
+
+const STYLE_TAG_DATA_ATTRIBUTE = 'data-plugin="dsh-wsl-workspace"'
+
+const STYLES = `
+/* Sidebar-foot icon action beside Settings (28px round in the wide sidebar,
+   36px round in the rail), matching the shell's icon-button language. */
+.dww-action {
+  flex: none;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 28px;
+  height: 28px;
+  border: none;
+  border-radius: 50%;
+  padding: 0;
+  background: transparent;
+  cursor: pointer;
+  color: var(--dsw-alias-label-secondary);
+  transition:
+    background-color 120ms var(--dsw-ease-in-out, ease-in-out),
+    color 120ms var(--dsw-ease-in-out, ease-in-out);
+}
+.dww-action:hover:not(:disabled) {
+  background: var(--dsw-alias-interactive-bg-hover);
+  color: var(--dsw-alias-label-secondary);
+}
+.dww-action:active:not(:disabled) {
+  background: var(--dsw-alias-interactive-bg-pressed, var(--dsw-alias-interactive-bg-hover));
+}
+.dww-action:focus-visible {
+  outline: 2px solid var(--dsw-alias-state-business-primary);
+  outline-offset: 1px;
+}
+.dww-action:disabled { cursor: default; opacity: 0.6; }
+.dww-action--rail {
+  width: 36px;
+  height: 36px;
+  color: var(--dsw-alias-label-primary);
+}
+.dww-action svg { flex: none; }
+
+/* The W letter mark of the sidebar action (sized for wide/rail buttons). */
+.dww-letter {
+  font-size: 14px;
+  font-weight: 600;
+  line-height: 1;
+  letter-spacing: 0.02em;
+  user-select: none;
+}
+.dww-action--rail .dww-letter { font-size: 17px; }
+
+/* Full-viewport overlay + centered card (mirrors the platform Mask/Dialog). */
+.dww-overlay {
+  position: fixed;
+  inset: 0;
+  z-index: 1000;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 24px;
+}
+.dww-overlay-mask {
+  position: absolute;
+  inset: 0;
+  background: var(--dsw-alias-bg-mask-1);
+  backdrop-filter: var(--dsw-mask-blur);
+}
+.dww-card {
+  position: relative;
+  z-index: 1;
+  box-sizing: border-box;
+  display: flex;
+  flex-direction: column;
+  width: min(440px, 100%);
+  max-height: min(640px, 90vh);
+  padding: 0 0 20px;
+  overflow: hidden;
+  border: 1px solid var(--dsw-alias-border-inverted);
+  border-radius: 16px;
+  background: var(--dsw-alias-bg-layer-2);
+  box-shadow: var(--dsw-shadow-lv3);
+  font-family: var(--dsw-font-family);
+}
+.dww-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  padding: 18px 20px 12px;
+}
+.dww-title {
+  margin: 0;
+  font-size: 16px;
+  line-height: 24px;
+  font-weight: 500;
+  color: var(--dsw-alias-label-primary);
+}
+.dww-close {
+  flex: none;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 28px;
+  height: 28px;
+  border: 0;
+  border-radius: 8px;
+  background: transparent;
+  cursor: pointer;
+  color: var(--dsw-alias-label-secondary);
+}
+.dww-close:hover { background: var(--dsw-alias-interactive-bg-hover); }
+.dww-body {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+  min-width: 0;
+  padding: 0 20px;
+  overflow: auto;
+}
+.dww-field { display: flex; flex-direction: column; gap: 6px; min-width: 0; }
+.dww-field-label {
+  font-size: 12px;
+  line-height: 18px;
+  color: var(--dsw-alias-label-secondary);
+}
+.dww-select {
+  box-sizing: border-box;
+  width: 100%;
+  height: 36px;
+  padding: 0 10px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 8px;
+  background: var(--dsw-alias-bg-layer-3);
+  color: var(--dsw-alias-label-primary);
+  font-size: 14px;
+}
+.dww-input-row { display: flex; gap: 8px; align-items: center; }
+.dww-input {
+  box-sizing: border-box;
+  flex: 1;
+  height: 36px;
+  min-width: 0;
+  padding: 0 10px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 8px;
+  background: var(--dsw-alias-bg-layer-3);
+  color: var(--dsw-alias-label-primary);
+  font-size: 14px;
+}
+.dww-input:focus, .dww-select:focus {
+  outline: none;
+  border-color: var(--dsw-alias-state-business-primary);
+}
+.dww-check-btn {
+  flex: none;
+  height: 36px;
+  padding: 0 12px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 8px;
+  background: transparent;
+  color: var(--dsw-alias-label-primary);
+  cursor: pointer;
+  font-size: 12px;
+}
+.dww-check-btn:hover:not(:disabled) { background: var(--dsw-alias-interactive-bg-hover); }
+.dww-check-btn:disabled { cursor: default; }
+
+/* Directory browse list. */
+.dww-dirlist {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  box-sizing: border-box;
+  min-height: 120px;
+  max-height: 200px;
+  padding: 4px;
+  overflow: auto;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 8px;
+  background: var(--dsw-alias-bg-layer-3);
+}
+.dww-breadcrumb {
+  padding: 0 4px;
+  font-size: 12px;
+  line-height: 18px;
+  color: var(--dsw-alias-label-tertiary);
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+.dww-dir-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  height: 28px;
+  padding: 0 8px;
+  border: 0;
+  border-radius: 6px;
+  background: transparent;
+  color: var(--dsw-alias-label-primary);
+  cursor: pointer;
+  font-size: 13px;
+  text-align: left;
+}
+.dww-dir-row:hover:not(:disabled) { background: var(--dsw-alias-interactive-bg-hover); }
+.dww-dir-row:disabled { cursor: default; color: var(--dsw-alias-label-tertiary); }
+.dww-dir-row--up { color: var(--dsw-alias-label-secondary); }
+.dww-dir-row svg { flex: none; color: var(--dsw-alias-label-tertiary); }
+.dww-dir-empty {
+  padding: 8px;
+  font-size: 12px;
+  line-height: 18px;
+  color: var(--dsw-alias-label-tertiary);
+}
+
+/* Error strip. */
+.dww-error {
+  box-sizing: border-box;
+  width: 100%;
+  padding: 8px 10px;
+  border: 1px solid var(--dsw-alias-state-error-primary);
+  border-radius: 8px;
+  color: var(--dsw-alias-state-error-primary);
+  font-size: 12px;
+  line-height: 18px;
+}
+.dww-retry {
+  margin-left: 6px;
+  border: 0;
+  background: transparent;
+  color: var(--dsw-alias-state-business-primary);
+  cursor: pointer;
+  font-size: 12px;
+  text-decoration: underline;
+}
+
+/* Dialog footer actions. */
+.dww-actions {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 8px;
+  padding: 14px 20px 0;
+}
+.dww-btn {
+  height: 36px;
+  padding: 0 14px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 8px;
+  background: transparent;
+  color: var(--dsw-alias-label-primary);
+  cursor: pointer;
+  font-size: 14px;
+}
+.dww-btn:hover:not(:disabled) { background: var(--dsw-alias-interactive-bg-hover); }
+.dww-btn--primary {
+  border-color: transparent;
+  background: var(--dsw-alias-button-primary-fill);
+  color: var(--dsw-alias-label-primary-foreground);
+}
+.dww-btn--primary:hover:not(:disabled) { background: var(--dsw-alias-button-primary-hover); }
+.dww-btn:disabled { cursor: default; opacity: 0.6; }
+`
+
+/**
+ * Idempotently inject the plugin stylesheet. No-op when a tag with the
+ * plugin's data attribute already exists.
+ */
+export function ensureStyles(): void {
+  if (typeof document === 'undefined') return
+  if (document.querySelector(`style[${STYLE_TAG_DATA_ATTRIBUTE}]`) !== null) return
+  const style = document.createElement('style')
+  style.setAttribute('data-plugin', 'dsh-wsl-workspace')
+  style.textContent = STYLES
+  document.head.appendChild(style)
+}