dsh-as-aistudio 0.2.13 → 0.3.0

package/src/components.js

@@ -26,7 +26,7 @@
 export const STUDIO_ID = 'dsh-as-aistudio'
 
 /** Keep in sync with package.json and src/client.js. */
-export const STUDIO_VERSION = '0.2.13'
+export const STUDIO_VERSION = '0.3.0'
 
 /**
  * The AI Studio action strip this studio composes, in the order the user meets

package/src/index.js

@@ -116,6 +116,27 @@ function safeGet(ctx, service) {
   }
 }
 
+/**
+ * The version of the code this studio actually runs.
+ *
+ * Both halves of every component are vendored here (tools/vendor.mjs writes
+ * src/vendor/versions.json as it copies them), so a component package does not
+ * even have to be installed. Reading the version off the installed package would
+ * therefore answer "unknown" on a perfectly working studio - the exact report
+ * this function replaces.
+ *
+ * @returns {Record<string, string>} component id -> vendored version.
+ */
+function vendoredVersions() {
+  try {
+    const raw = readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), 'vendor', 'versions.json'), 'utf8')
+    const parsed = JSON.parse(raw)
+    return parsed !== null && typeof parsed === 'object' ? parsed : {}
+  } catch {
+    return {}
+  }
+}
+
 /**
  * Resolve one component package from the profile.
  * @param pkg - the bare package name.
@@ -251,6 +272,7 @@ export function hostStateOf(component, entries, installed) {
 export function statusOf(ctx) {
   const entries = loaderEntries(ctx)
   const anchors = resolveAnchors(ctx)
+  const vendored = vendoredVersions()
   const components = COMPONENTS.map((component) => {
     const found = inspectPackage(component.package, anchors)
     const host = hostStateOf(component, entries, found.installed)
@@ -265,7 +287,10 @@ export function statusOf(ctx) {
       kind: component.kind,
       repo: component.repo,
       installed: found.installed,
-      version: found.version,
+      // The version of the copy that is RUNNING. `installedVersion` is the
+      // package in the profile, which may be absent or a different build.
+      version: vendored[component.id] ?? found.version,
+      installedVersion: found.version,
       hostMounted: host.hostMounted,
       hostReason: host.hostReason,
       hostRow: host.hostRow,

package/src/shell.js

@@ -6,7 +6,7 @@
 // file - and carries the real component package in `config.plugin`. The shell
 // is what turns that name into a mount:
 //
-//     const namespace = await import(config.plugin)
+//     const namespace = await import('./vendor/host/' + id + '.js')
 //     await ctx.plugin(namespace.default ?? namespace.plugin ?? namespace)
 //
 // Why the row is a subpath of this package and not the component's own name:
@@ -28,7 +28,13 @@
 //
 // The row config is read once per activation. Editing it in the plugin manager
 // restarts the entry, which runs this apply again with the new value.
-import { STUDIO_ID } from './components.js'
+//
+// The component's HOST half is vendored into this package (tools/vendor.mjs),
+// exactly like its browser half: `config.plugin` names which component the row
+// is, and the vendored file beside this one is what gets mounted. That is why
+// installing the studio installs nothing else - and why a component's fix
+// reaches the studio only through a re-vendor and a studio release.
+import { COMPONENTS, STUDIO_ID } from './components.js'
 import { pluginOf } from './index.js'
 
 /** Loader display name of this shell (all four rows share it). */
@@ -64,6 +70,14 @@ export const Config = {
   },
 }
 
+/** The component id a row's `plugin` names, or null when it names none of ours. */
+function componentIdOf(spec) {
+  for (const component of COMPONENTS) {
+    if (component.package === spec) return component.id
+  }
+  return null
+}
+
 /** The package name a row config names, or null when it names none. */
 function pluginSpecOf(config) {
   if (config === null || config === undefined || typeof config !== 'object') return null
@@ -103,11 +117,22 @@ export async function apply(ctx, config) {
       STUDIO_ID + ': this component row names no plugin; set config.plugin to the component package (row config: ' + describeConfig(config) + ')',
     )
   }
+  const id = componentIdOf(spec)
+  if (id === null) {
+    throw new Error(
+      STUDIO_ID +
+        ': component ' +
+        JSON.stringify(spec) +
+        ' is not one of this studio\'s components (' +
+        COMPONENTS.map((component) => component.package).join(', ') +
+        ')',
+    )
+  }
   let namespace
   try {
-    // The component is a dependency of this package, so the bare specifier
-    // resolves from the profile that installed the studio.
-    namespace = await import(spec)
+    // The host half is vendored beside this file (tools/vendor.mjs), so the
+    // component package does not have to be installed at all.
+    namespace = await import('./vendor/host/' + id + '.js')
   } catch (error) {
     throw new Error(
       STUDIO_ID + ': component ' + JSON.stringify(spec) + ' could not be imported: ' + messageOf(error),

package/src/vendor/host/_platform.js

@@ -0,0 +1,132 @@
+// The platform packages a vendored component host half may import.
+//
+// A component copied into this package must NOT get its own copy of
+// `@deepseek-ai/dsh-session`: two module instances mean two registries, and the
+// second copy's `appendPluginRecord` cannot touch a Session the host created
+// (the brand check inside it throws). The same goes for `dsh-tools`, whose
+// `defineTool` builds validators against schemas the host's own tool registry
+// expects.
+//
+// So the copies import THIS file, and this file resolves the two packages from
+// the running harness. The harness lives in the `dsh` installation, so the base
+// is found by walking up from this file to the nearest node_modules that has it,
+// with the profile's own tree as the second try. A failure here is a failure of
+// the whole component row and says exactly which package was missing - silence
+// would report a component that never started.
+
+import { createRequire } from 'node:module'
+import { existsSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const here = dirname(fileURLToPath(import.meta.url))
+
+/**
+ * Candidate base directories, nearest-first, for resolving a platform package.
+ *
+ * Two roots, because a plugin is loaded from one tree and the harness runs from
+ * another: this file's own ancestors (a profile that installed the packages
+ * beside it), then the RUNNING process's entry point - `process.argv[1]` is the
+ * `dsh` binary, and the platform packages sit in that installation's
+ * `node_modules`. ESM resolves relative to the importing FILE, so the second
+ * root has to be built by hand.
+ *
+ * @returns directory list to try with createRequire.
+ */
+function bases() {
+  const out = []
+  const seen = new Set()
+  const add = (start) => {
+    if (typeof start !== 'string' || start === '') return
+    let node = start
+    for (let up = 0; up < 10; up += 1) {
+      const candidate = join(node, 'node_modules')
+      if (!seen.has(candidate) && existsSync(candidate)) {
+        seen.add(candidate)
+        out.push(candidate)
+      }
+      const parent = dirname(node)
+      if (parent === node) break
+      node = parent
+    }
+  }
+  add(here)
+  add(typeof process !== 'undefined' && process.argv ? process.argv[1] : '')
+  add(typeof process !== 'undefined' ? process.cwd() : '')
+  return out
+}
+
+/**
+ * Resolve one platform package and import it as ESM.
+ *
+ * @param spec - the platform package name.
+ * @returns its module namespace.
+ * @throws when no candidate base can resolve it, naming the specifier.
+ */
+async function importPlatform(spec) {
+  for (const base of bases()) {
+    try {
+      const url = createRequire(join(base, 'noop.js')).resolve(spec)
+      return await import(url)
+    } catch {
+      continue
+    }
+  }
+  // Last resort: the bare specifier, which works when the caller (the profile)
+  // can already resolve it.
+  try {
+    return await import(spec)
+  } catch (error) {
+    throw new Error(
+      'dsh-as-aistudio: the platform package ' +
+        JSON.stringify(spec) +
+        ' could not be resolved from ' +
+        here +
+        '; it ships with the dsh installation, so this copy is being loaded outside a harness (' +
+        String((error && error.message) || error) +
+        ')',
+      { cause: error },
+    )
+  }
+}
+
+/**
+ * Resolve one platform package, or fail with a message that names it.
+ *
+ * Eager on purpose: a component whose platform package is missing must fail its
+ * row loudly (the Loader records the reason and /status reports hostMounted:
+ * false), never mount half a feature and answer "unsupported" forever after.
+ *
+ * @param spec - the platform package name.
+ * @returns its module namespace.
+ */
+async function importPlatformOrThrow(spec) {
+  for (const base of bases()) {
+    try {
+      const url = createRequire(join(base, 'noop.js')).resolve(spec)
+      return await import(url)
+    } catch {
+      continue
+    }
+  }
+  try {
+    return await import(spec)
+  } catch (error) {
+    throw new Error(
+      'dsh-as-aistudio: the platform package ' +
+        JSON.stringify(spec) +
+        ' could not be resolved from ' +
+        here +
+        '; it ships with the dsh installation, so this copy is being loaded outside a harness (' +
+        String((error && error.message) || error) +
+        ')',
+      { cause: error },
+    )
+  }
+}
+
+/** `@deepseek-ai/dsh-tools`, resolved from the running harness. */
+export const dshTools = await importPlatformOrThrow('@deepseek-ai/dsh-tools')
+
+/** `@deepseek-ai/dsh-session`, resolved from the running harness. */
+export const dshSession = await importPlatformOrThrow('@deepseek-ai/dsh-session')