dsh-managed-workspaces 0.0.0-stage → 1.0.0

package/context.js

@@ -0,0 +1,78 @@
+// dsh-managed-workspaces: prompt context for sessions inside a managed workspace.
+//
+// The working-directory context already states the current directory; this
+// contribution explains the workspace root, the linked folders, and the two
+// consequences the model cannot discover by itself: search and sandbox roots.
+
+/**
+ * Render the managed-workspace prompt section for one workspace.
+ * @param {{name: string, path: string, links: Array<{alias: string, target: string}>}} workspace - workspace facts.
+ * @param {string} linksDirectoryName - reserved links directory name.
+ * @returns {string} the prompt text.
+ */
+export function renderContext(workspace, linksDirectoryName) {
+  const links = workspace.links
+  const lines = [
+    `Managed workspace "${workspace.name}"`,
+    `Root: "${workspace.path}"`,
+  ]
+  if (links.length === 0) {
+    lines.push('Linked folders: none.')
+  } else {
+    lines.push(`Linked folders (each is a directory link at "<root>/${linksDirectoryName}/<alias>"):`)
+    for (const link of links) {
+      lines.push(`- "${link.alias}" -> "${link.target}"`)
+    }
+  }
+  lines.push(
+    'Path rules: relative paths resolve from Root. Work inside a linked folder through the path '
+      + `"${linksDirectoryName}/<alias>/..." (or its absolute target path).`,
+  )
+  if (links.length > 0) {
+    lines.push(
+      'Searching: glob and grep read through an explicit path, so search a linked folder with '
+        + `path "${linksDirectoryName}/<alias>"; a search rooted at Root may not descend into the links.`,
+    )
+    lines.push(
+      'Sandbox: linked targets lie outside the session workspace root, so workspace-write denies writes there. '
+        + 'Switch the session to danger-full-access when a task must modify linked folders.',
+    )
+  }
+  return lines.join('\n')
+}
+
+/**
+ * Register the system-prompt contribution for managed workspaces.
+ * @param {object} ctx - plugin context providing `systemPrompt` and `workingDirectory`.
+ * @param {import('./store.js').ManagedWorkspaceStore} store - state owner.
+ * @returns {() => void} disposer.
+ */
+export function registerManagedWorkspaceContext(ctx, store) {
+  const dispose = ctx.systemPrompt.context({
+    name: 'workspace:managed',
+    order: 300,
+    interpolate: false,
+    text: (context) => {
+      const session = context.agent?.session
+      if (session === undefined) return ''
+      let directory
+      try {
+        directory = ctx.workingDirectory.get(session)
+      } catch {
+        directory = session.header.cwd
+      }
+      const found = store.findWorkspaceForPath(directory)
+      if (found === null) return ''
+      const linksDirectoryName = store.manifest?.linksDirectoryName ?? '_roots'
+      return renderContext(
+        {
+          name: found.workspace.name,
+          path: found.workspace.path,
+          links: found.workspace.links.map((link) => ({ alias: link.alias, target: link.target })),
+        },
+        linksDirectoryName,
+      )
+    },
+  })
+  return typeof dispose === 'function' ? dispose : () => {}
+}

package/cordis.patch.yml

@@ -0,0 +1,10 @@
+# dsh-managed-workspaces bundle patch.
+#
+# One plugin row: the host half (exports ".") owns the workspace manifest, the
+# junction links, the `/dsh-managed-workspaces/api/*` routes, the
+# `managed_workspace` tool, and the prompt context; the `dsh.client`
+# declaration in package.json makes the browser half (exports "./client") load
+# in the Web GUI.
+- insert:
+    - id: dsh-managed-workspaces
+      name: 'dsh-managed-workspaces'

package/icon.svg

@@ -0,0 +1,14 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="Managed workspaces">
+  <defs>
+    <linearGradient id="mwsFolder" x1="0" y1="0" x2="0" y2="1">
+      <stop offset="0" stop-color="#4c8dff"/>
+      <stop offset="1" stop-color="#2563d9"/>
+    </linearGradient>
+  </defs>
+  <rect width="64" height="64" rx="14" fill="#eef3ff"/>
+  <path d="M12 22a4 4 0 0 1 4-4h11l4 4h13a4 4 0 0 1 4 4v18a4 4 0 0 1-4 4H16a4 4 0 0 1-4-4z" fill="url(#mwsFolder)"/>
+  <path d="M12 28h40v14a4 4 0 0 1-4 4H16a4 4 0 0 1-4-4z" fill="#6ea2ff" opacity="0.55"/>
+  <circle cx="46" cy="42" r="11" fill="#1f4fb8"/>
+  <path d="M46 36.5v11M40.5 42h11" stroke="#fff" stroke-width="3.2" stroke-linecap="round"/>
+  <path d="M18 49h19" stroke="#fff" stroke-width="3" stroke-linecap="round" opacity="0.85"/>
+</svg>

package/index.js

@@ -0,0 +1,50 @@
+// dsh-managed-workspaces: Host half.
+//
+// Owns the workspace manifest, the workspace folders and their linked folders,
+// the browser JSON routes, the `managed_workspace` tool, and the prompt context.
+// The Web client half lives in client.js.
+
+import { ManagedWorkspaceStore } from './store.js'
+import { registerRoutes } from './routes.js'
+import { createManagedWorkspaceTool } from './tool.js'
+import { registerManagedWorkspaceContext } from './context.js'
+
+export const name = 'dsh-managed-workspaces'
+
+/** Mount every capability the host provides, each disposed with this plugin fiber. */
+export function apply(ctx) {
+  const warn = (message) => {
+    try {
+      ctx.logger?.warn?.(String(message))
+    } catch {
+      // Logging must never break the plugin.
+    }
+  }
+
+  const store = new ManagedWorkspaceStore({ logger: warn })
+  ctx.effect(() => () => store.dispose(), 'dsh-managed-workspaces: store')
+  store.load().catch((error) => warn(`failed to load the managed workspace manifest: ${error?.message ?? error}`))
+
+  ctx.inject(['webServer'], (scope) => {
+    scope.effect(() => registerRoutes(scope, store), 'dsh-managed-workspaces: routes')
+  })
+
+  ctx.inject(['workspaceRegistry'], (scope) => {
+    store.setRegistry(scope.workspaceRegistry)
+    scope.effect(() => () => store.setRegistry(null), 'dsh-managed-workspaces: registry')
+  })
+
+  ctx.inject(['tools'], (scope) => {
+    scope.effect(
+      () => scope.tools.register(createManagedWorkspaceTool(scope, store)),
+      'dsh-managed-workspaces: tool',
+    )
+  })
+
+  ctx.inject(['workingDirectory', 'systemPrompt'], (scope) => {
+    scope.effect(
+      () => registerManagedWorkspaceContext(scope, store),
+      'dsh-managed-workspaces: context',
+    )
+  })
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Managed workspaces",
+    "description": "Creates workspace folders under a base directory and links several folders into one workspace."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "托管工作区",
+    "description": "在指定根目录下自动创建工作区文件夹，并把多个文件夹关联到同一个工作区。"
+  }
+}

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "dsh-managed-workspaces",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "type": "module",
+  "description": "DSH-owned workspaces created under a configurable base directory, with multiple linked folders per workspace.",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "dsh-bundle",
+    "workspace",
+    "multi-root"
+  ],
+  "license": "MIT",
+  "author": "CoraxEldridge",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CoraxEldridge/dsh-managed-workspaces.git"
+  },
+  "homepage": "https://github.com/CoraxEldridge/dsh-managed-workspaces#readme",
+  "bugs": {
+    "url": "https://github.com/CoraxEldridge/dsh-managed-workspaces/issues"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "store.js",
+    "routes.js",
+    "tool.js",
+    "context.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "LICENSE"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true
+    }
+  }
+}

package/routes.js

@@ -0,0 +1,118 @@
+// dsh-managed-workspaces: HTTP routes for the browser half.
+//
+// The host plugin owns the operations; these routes are a thin JSON transport
+// for the Web GUI. They are registered on the harness web server and removed
+// with the plugin fiber.
+
+import { ManagedWorkspaceError, errorMessage } from './store.js'
+
+const API_PREFIX = '/dsh-managed-workspaces/api/'
+const GUARD_HEADER = 'x-dsh-managed-workspaces'
+const MAX_BODY_BYTES = 64 * 1024
+
+function errorPayload(error) {
+  if (error instanceof ManagedWorkspaceError) {
+    return {
+      code: error.code,
+      message: error.message,
+      ...(error.details === undefined ? {} : { details: error.details }),
+    }
+  }
+  return { code: 'internal', message: errorMessage(error) }
+}
+
+function sendJson(response, status, payload) {
+  if (response.writableEnded || response.destroyed) return
+  response.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+  })
+  response.end(JSON.stringify(payload))
+}
+
+async function readBody(request) {
+  const chunks = []
+  let total = 0
+  for await (const chunk of request) {
+    total += chunk.length
+    if (total > MAX_BODY_BYTES) {
+      throw new ManagedWorkspaceError('body-too-large', `request body exceeds ${MAX_BODY_BYTES} bytes`)
+    }
+    chunks.push(chunk)
+  }
+  return Buffer.concat(chunks).toString('utf8')
+}
+
+function routeHandler(operation) {
+  return async (request, response) => {
+    try {
+      if (request.method !== 'POST') {
+        sendJson(response, 405, { ok: false, error: { code: 'method-not-allowed', message: 'POST required' } })
+        return
+      }
+      if (request.headers[GUARD_HEADER] !== '1') {
+        sendJson(response, 403, { ok: false, error: { code: 'forbidden', message: 'missing request marker header' } })
+        return
+      }
+      const body = await readBody(request)
+      let args = {}
+      if (body.trim().length > 0) {
+        try {
+          args = JSON.parse(body)
+        } catch {
+          sendJson(response, 400, { ok: false, error: { code: 'bad-json', message: 'request body is not JSON' } })
+          return
+        }
+      }
+      if (args === null || typeof args !== 'object' || Array.isArray(args)) {
+        sendJson(response, 400, { ok: false, error: { code: 'bad-json', message: 'request body must be a JSON object' } })
+        return
+      }
+      const result = await operation(args, request)
+      sendJson(response, 200, { ok: true, ...(result ?? {}) })
+    } catch (error) {
+      const status = error instanceof ManagedWorkspaceError && error.code === 'body-too-large' ? 413 : 200
+      sendJson(response, status, { ok: false, error: errorPayload(error) })
+    }
+  }
+}
+
+/**
+ * Register every plugin route on the hosting web server.
+ * @param {object} ctx - plugin context providing `webServer`.
+ * @param {import('./store.js').ManagedWorkspaceStore} store - state owner.
+ * @returns {() => void} disposer removing every route.
+ */
+export function registerRoutes(ctx, store) {
+  const webServer = ctx.webServer
+  const disposers = []
+  const route = (name, operation) => {
+    disposers.push(
+      webServer.register({
+        kind: 'exact',
+        path: API_PREFIX + name,
+        handler: routeHandler(operation),
+      }),
+    )
+  }
+
+  route('state', async () => store.state())
+  route('config', async (args) => store.setBaseDirectory(args.baseDirectory))
+  route('create', async (args) => store.create(args.name))
+  route('adopt', async (args) => (args.all === true ? store.adoptAll() : store.adopt(args.folder)))
+  route('attach', async (args) => store.attach(args.id, args.folder, args.alias))
+  route('detach', async (args) => store.detach(args.id, args.alias))
+  route('register', async (args) => store.register(args.id))
+  route('forget', async (args) => store.forget(args.id))
+  route('repair', async (args) => store.repair(args.id))
+
+  return () => {
+    for (const dispose of disposers) {
+      try {
+        dispose()
+      } catch {
+        // A route already removed by a reload must not block the rest.
+      }
+    }
+  }
+}