@dsh-workbench/shared 1.1.7 → 1.1.9

package/dist/host/package-route.d.ts

@@ -0,0 +1,31 @@
+import type { DshShell } from '../api/dsh.js';
+export type PackageRouteKind = 'runtime-plugin' | 'dsh-bundle' | 'neither';
+export interface PackageRoute {
+    readonly kind: PackageRouteKind;
+    readonly pkg?: string;
+    readonly pluginName?: string;
+}
+export interface PackageRouter {
+    packageRouteOf(options: RouteOptions): Promise<PackageRoute | undefined>;
+    reset(): void;
+}
+interface RouteOptions {
+    readonly spec: string;
+    readonly shell?: DshShell | undefined;
+    readonly registry?: string | undefined;
+    readonly force?: boolean;
+}
+export interface PackageRouterOptions {
+    readonly manifestFile: string;
+    readonly cacheDir?: string | undefined;
+    readonly dshLookup?: ((options: {
+        shell: DshShell;
+        name: string;
+        registry: string;
+    }) => Promise<{
+        readable: boolean;
+        raw: unknown;
+    }>) | undefined;
+}
+export declare function createPackageRouter(options: PackageRouterOptions): PackageRouter;
+export {};

package/dist/host/package-route.js

@@ -0,0 +1,57 @@
+import { VERSION_CHECK_TTL_MS } from '../config/constants.js';
+import { dshMarkersOf, splitNpmSpec, verdictOf } from './package-kind.js';
+import { withPackageDir } from './package-content.js';
+import { localDirOf } from './local-declaration.js';
+function routeOfVerdict(verdict, fallback) {
+    const pkg = verdict.pkg ?? fallback;
+    if (verdict.kind === 'neither')
+        return { kind: 'neither', ...(pkg === undefined ? {} : { pkg }) };
+    if (verdict.kind === 'dsh-bundle' || verdict.kind === 'both')
+        return { kind: 'dsh-bundle' };
+    return {
+        kind: 'runtime-plugin',
+        ...(pkg === undefined ? {} : { pkg }),
+        ...(verdict.pluginName === undefined ? {} : { pluginName: verdict.pluginName }),
+    };
+}
+export function createPackageRouter(options) {
+    const cache = new Map();
+    return {
+        packageRouteOf: (routeOptions) => routeOf(cache, options, routeOptions),
+        reset: () => {
+            cache.clear();
+        },
+    };
+}
+async function routeOf(cache, options, routeOptions) {
+    const local = localDirOf(routeOptions.spec);
+    if (local !== undefined) {
+        const verdict = verdictOf(local, options.manifestFile);
+        return verdict === undefined ? undefined : routeOfVerdict(verdict, splitNpmSpec(routeOptions.spec)?.name);
+    }
+    const ref = splitNpmSpec(routeOptions.spec);
+    if (ref === undefined)
+        return undefined;
+    const shell = routeOptions.shell;
+    const registry = routeOptions.registry;
+    if (shell === undefined || registry === undefined)
+        return undefined;
+    const key = `${registry}|${routeOptions.spec}`;
+    const hit = cache.get(key);
+    if (routeOptions.force !== true && hit !== undefined && Date.now() - hit.at < VERSION_CHECK_TTL_MS) {
+        return hit.route ?? undefined;
+    }
+    const found = options.dshLookup === undefined
+        ? { readable: false, raw: undefined }
+        : await options.dshLookup({ shell, name: routeOptions.spec, registry });
+    let route;
+    if (found.readable && dshMarkersOf(found.raw)) {
+        route = { kind: 'dsh-bundle' };
+    }
+    else {
+        const verdict = await withPackageDir({ shell, spec: routeOptions.spec, registry, ...(options.cacheDir === undefined ? {} : { cacheDir: options.cacheDir }) }, (dir) => verdictOf(dir, options.manifestFile));
+        route = verdict === undefined ? undefined : routeOfVerdict(verdict, ref.name);
+    }
+    cache.set(key, { at: Date.now(), route: route ?? null });
+    return route;
+}

package/dist/host/paths.d.ts

@@ -1,19 +1,11 @@
-export declare function isolatedRoot(): string;
-export declare function isolatedHome(): string;
-export declare function vendorPrefix(): string;
-export declare function vendorPluginsDir(): string;
-export declare function libsPrefix(): string;
-export declare const OPENCLI_NPM_PACKAGE = "@jackwener/opencli";
-export declare function toolchainOpencliDir(): string;
-export declare function vendorPeerLink(): {
-    readonly dir: string;
-    readonly parent: string;
-};
-export declare function npmCacheDir(): string;
-export declare function libsBinDir(): string;
-/**
- * 把隔离运行时的共用依赖 bin 目录放到 PATH 最前面（可执行文件都从这儿找）。
- * @param env 改哪份环境（默认当前进程）。
- * @returns 真的插进去了就 `true`；已经在里面就 `false`。
- */
-export declare function ensureLibsBinOnPath(env?: NodeJS.ProcessEnv): boolean;
+export interface RuntimeLayout {
+    readonly root: string;
+    readonly home: string;
+    readonly vendorPrefix: string;
+    readonly vendorPluginsDir: string;
+    readonly libsPrefix: string;
+    readonly libsBinDir: string;
+    readonly npmCacheDir: string;
+}
+export declare function runtimeRootOf(id: string): string;
+export declare function runtimeLayoutOf(id: string): RuntimeLayout;

package/dist/host/paths.js

@@ -1,45 +1,18 @@
-import { delimiter } from 'node:path';
 import { workbenchRoot } from './data-root.js';
-export function isolatedRoot() {
-    return `${workbenchRoot()}/opencli`;
-}
-export function isolatedHome() {
-    return `${isolatedRoot()}/home`;
-}
-export function vendorPrefix() {
-    return `${isolatedRoot()}/plugins-npm`;
-}
-export function vendorPluginsDir() {
-    return `${vendorPrefix()}/node_modules`;
-}
-export function libsPrefix() {
-    return `${isolatedRoot()}/libs`;
-}
-export const OPENCLI_NPM_PACKAGE = '@jackwener/opencli';
-export function toolchainOpencliDir() {
-    return `${isolatedRoot()}/toolchain/node_modules/${OPENCLI_NPM_PACKAGE}`;
-}
-export function vendorPeerLink() {
-    const base = `${vendorPrefix()}/node_modules`;
-    const [scope] = OPENCLI_NPM_PACKAGE.split('/');
-    return { dir: `${base}/${OPENCLI_NPM_PACKAGE}`, parent: `${base}/${scope}` };
-}
-export function npmCacheDir() {
-    return `${isolatedRoot()}/npm-cache`;
-}
-export function libsBinDir() {
-    return `${libsPrefix()}/node_modules/.bin`;
-}
-/**
- * 把隔离运行时的共用依赖 bin 目录放到 PATH 最前面（可执行文件都从这儿找）。
- * @param env 改哪份环境（默认当前进程）。
- * @returns 真的插进去了就 `true`；已经在里面就 `false`。
- */
-export function ensureLibsBinOnPath(env = process.env) {
-    const dir = libsBinDir();
-    const parts = (env.PATH ?? '').split(delimiter).filter((one) => one !== '');
-    if (parts.includes(dir))
-        return false;
-    env.PATH = [dir, ...parts].join(delimiter);
-    return true;
+export function runtimeRootOf(id) {
+    return `${workbenchRoot()}/${id}`;
+}
+export function runtimeLayoutOf(id) {
+    const root = runtimeRootOf(id);
+    const vendorPrefix = `${root}/plugins-npm`;
+    const libsPrefix = `${root}/libs`;
+    return {
+        root,
+        home: `${root}/home`,
+        vendorPrefix,
+        vendorPluginsDir: `${vendorPrefix}/node_modules`,
+        libsPrefix,
+        libsBinDir: `${libsPrefix}/node_modules/.bin`,
+        npmCacheDir: `${root}/npm-cache`,
+    };
 }

package/dist/host/platform.js

@@ -33,7 +33,7 @@ export function hostSurface(input = {}) {
         restartHint: deployment === 'desktop' ? '退出并重开 Desktop' : '重启一次 dsh',
         toolchain: {
             node: { source: deployment === 'desktop' ? 'desktop-shim' : 'path' },
-            npm: { neededFor: 'opencli-install' },
+            npm: { neededFor: 'runtime-install' },
             pnpm: { neededFor: 'workshop', expectedMajor: 10 },
         },
     };

package/dist/host/plugin-ledger.d.ts

@@ -1,7 +1,7 @@
 import type { ModuleStore } from './workspace-store.js';
 export declare const PLUGIN_LEDGER_FILE = "plugins.json";
 export interface PluginLedgerEntry {
-    readonly opencliHome: string;
+    readonly home: string;
     readonly package: string;
     readonly name?: string;
     readonly registry?: string;
@@ -10,23 +10,23 @@ export interface PluginLedgerEntry {
     readonly releasedAt?: string;
 }
 export declare function ledgerKeyOf(entry: {
-    readonly opencliHome: string;
+    readonly home: string;
     readonly package: string;
 }): string;
 export declare function parsePluginLedger(raw: unknown): PluginLedgerEntry[];
 export declare function readPluginLedger(store: ModuleStore): PluginLedgerEntry[];
 export declare function writePluginLedger(store: ModuleStore, entries: readonly PluginLedgerEntry[]): void;
-export declare function pluginEntriesOfHome(entries: readonly PluginLedgerEntry[], opencliHome: string): PluginLedgerEntry[];
+export declare function pluginEntriesOfHome(entries: readonly PluginLedgerEntry[], home: string): PluginLedgerEntry[];
 export declare function isHeldEntry(entry: PluginLedgerEntry): boolean;
-export declare function heldEntriesOfHome(entries: readonly PluginLedgerEntry[], opencliHome: string): PluginLedgerEntry[];
-export declare function heldEntryOfPlugin(entries: readonly PluginLedgerEntry[], opencliHome: string, plugin: string): PluginLedgerEntry | undefined;
-export declare function withReleasedEntry(entries: readonly PluginLedgerEntry[], opencliHome: string, pkg: string, releasedAt: string): PluginLedgerEntry[];
+export declare function heldEntriesOfHome(entries: readonly PluginLedgerEntry[], home: string): PluginLedgerEntry[];
+export declare function heldEntryOfPlugin(entries: readonly PluginLedgerEntry[], home: string, plugin: string): PluginLedgerEntry | undefined;
+export declare function withReleasedEntry(entries: readonly PluginLedgerEntry[], home: string, pkg: string, releasedAt: string): PluginLedgerEntry[];
 export type PluginRetention = 'remove' | 'keep-held' | 'keep-claimed' | 'keep-unsure';
 export declare function pluginRetentionOf(options: {
     readonly held: boolean;
     readonly claimedBy: readonly string[];
     readonly trustworthy: boolean;
 }): PluginRetention;
-export declare function pluginEntryOf(entries: readonly PluginLedgerEntry[], opencliHome: string, pkg: string): PluginLedgerEntry | undefined;
+export declare function pluginEntryOf(entries: readonly PluginLedgerEntry[], home: string, pkg: string): PluginLedgerEntry | undefined;
 export declare function withPluginEntry(entries: readonly PluginLedgerEntry[], entry: PluginLedgerEntry): PluginLedgerEntry[];
-export declare function withoutPluginEntry(entries: readonly PluginLedgerEntry[], opencliHome: string, pkg: string): PluginLedgerEntry[];
+export declare function withoutPluginEntry(entries: readonly PluginLedgerEntry[], home: string, pkg: string): PluginLedgerEntry[];

package/dist/host/plugin-ledger.js

@@ -1,6 +1,6 @@
 export const PLUGIN_LEDGER_FILE = 'plugins.json';
 export function ledgerKeyOf(entry) {
-    return `${entry.opencliHome}\u0000${entry.package}`;
+    return `${entry.home}\u0000${entry.package}`;
 }
 function textOf(value) {
     if (typeof value !== 'string')
@@ -8,20 +8,27 @@ function textOf(value) {
     const trimmed = value.trim();
     return trimmed === '' ? undefined : trimmed;
 }
+function legacyHomeOf(box) {
+    for (const [key, value] of Object.entries(box)) {
+        if (key !== 'home' && key.toLowerCase().endsWith('home'))
+            return value;
+    }
+    return undefined;
+}
 function entryOf(value) {
     if (typeof value !== 'object' || value === null)
         return undefined;
     const box = value;
-    const opencliHome = textOf(box['opencliHome']);
+    const home = textOf(box['home']) ?? textOf(legacyHomeOf(box));
     const pkg = textOf(box['package']);
     const installedAt = textOf(box['installedAt']);
-    if (opencliHome === undefined || pkg === undefined || installedAt === undefined)
+    if (home === undefined || pkg === undefined || installedAt === undefined)
         return undefined;
     const name = textOf(box['name']);
     const registry = textOf(box['registry']);
     const releasedAt = textOf(box['releasedAt']);
     return {
-        opencliHome,
+        home,
         package: pkg,
         installedAt,
         ...(name === undefined ? {} : { name }),
@@ -57,23 +64,23 @@ export function writePluginLedger(store, entries) {
     }
     store.write(PLUGIN_LEDGER_FILE, { entries });
 }
-export function pluginEntriesOfHome(entries, opencliHome) {
-    return entries.filter((entry) => entry.opencliHome === opencliHome);
+export function pluginEntriesOfHome(entries, home) {
+    return entries.filter((entry) => entry.home === home);
 }
 export function isHeldEntry(entry) {
     return entry.releasedAt === undefined;
 }
-export function heldEntriesOfHome(entries, opencliHome) {
-    return pluginEntriesOfHome(entries, opencliHome).filter(isHeldEntry);
+export function heldEntriesOfHome(entries, home) {
+    return pluginEntriesOfHome(entries, home).filter(isHeldEntry);
 }
-export function heldEntryOfPlugin(entries, opencliHome, plugin) {
+export function heldEntryOfPlugin(entries, home, plugin) {
     const key = plugin.trim();
     if (key === '')
         return undefined;
-    return heldEntriesOfHome(entries, opencliHome).find((entry) => entry.name === key || entry.package === key);
+    return heldEntriesOfHome(entries, home).find((entry) => entry.name === key || entry.package === key);
 }
-export function withReleasedEntry(entries, opencliHome, pkg, releasedAt) {
-    const entry = pluginEntryOf(entries, opencliHome, pkg);
+export function withReleasedEntry(entries, home, pkg, releasedAt) {
+    const entry = pluginEntryOf(entries, home, pkg);
     if (entry === undefined || entry.releasedAt !== undefined)
         return [...entries];
     return withPluginEntry(entries, { ...entry, releasedAt });
@@ -85,15 +92,15 @@ export function pluginRetentionOf(options) {
         return 'keep-unsure';
     return options.claimedBy.length > 0 ? 'keep-claimed' : 'remove';
 }
-export function pluginEntryOf(entries, opencliHome, pkg) {
-    const key = ledgerKeyOf({ opencliHome, package: pkg });
+export function pluginEntryOf(entries, home, pkg) {
+    const key = ledgerKeyOf({ home, package: pkg });
     return entries.find((entry) => ledgerKeyOf(entry) === key);
 }
 export function withPluginEntry(entries, entry) {
     const key = ledgerKeyOf(entry);
     return [...entries.filter((item) => ledgerKeyOf(item) !== key), entry];
 }
-export function withoutPluginEntry(entries, opencliHome, pkg) {
-    const key = ledgerKeyOf({ opencliHome, package: pkg });
+export function withoutPluginEntry(entries, home, pkg) {
+    const key = ledgerKeyOf({ home, package: pkg });
     return entries.filter((entry) => ledgerKeyOf(entry) !== key);
 }

package/dist/host/plugin.d.ts

@@ -1,4 +1,3 @@
-export declare const OPENCLI_MANIFEST_FILE = "opencli-plugin.json";
-export declare function pluginAt(dir: string): {
+export declare function pluginAt(dir: string, manifestFile: string): {
     readonly name?: string;
 } | undefined;

package/dist/host/plugin.js

@@ -1,6 +1,5 @@
 import { readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
-export const OPENCLI_MANIFEST_FILE = 'opencli-plugin.json';
 function asRecord(value) {
     return typeof value === 'object' && value !== null ? value : undefined;
 }
@@ -11,9 +10,9 @@ function isCommandFile(name) {
         return false;
     return name.endsWith('.ts') || name.endsWith('.js');
 }
-function pluginManifestOf(dir) {
+function pluginManifestOf(dir, manifestFile) {
     try {
-        const parsed = JSON.parse(readFileSync(join(dir, OPENCLI_MANIFEST_FILE), 'utf8'));
+        const parsed = JSON.parse(readFileSync(join(dir, manifestFile), 'utf8'));
         if (Array.isArray(parsed))
             return undefined;
         return asRecord(parsed);
@@ -30,8 +29,8 @@ function hasCommandFile(dir) {
         return false;
     }
 }
-export function pluginAt(dir) {
-    const manifest = pluginManifestOf(dir);
+export function pluginAt(dir, manifestFile) {
+    const manifest = pluginManifestOf(dir, manifestFile);
     if (manifest === undefined || !hasCommandFile(dir))
         return undefined;
     const name = manifest.name;

package/dist/host/port-types.d.ts

@@ -1,10 +1,14 @@
 import type { DshHostContext, DshShell } from '../api/dsh.js';
+import type { RuntimeCapabilities, RuntimeProfile } from '../contract/capabilities.js';
+import type { PluginPackageKind } from '../contract/protocol/bundle-install.js';
 import type { LibNeed, SupplySource } from '../contract/needs.js';
 import type { NeedProbeInput, UnitCapability } from '../contract/unit-capability.js';
+import type { DataReader } from '../contract/data.js';
+import type { LibRunner } from '../contract/runner.js';
 import type { WorkbenchSelfUpdate } from '../contract/protocol/bundle-install.js';
-import type { BundleManager, InstalledModule, OpencliResolution, ProfileModule, ProfilePackage, RegistryNotebook, SelfUpdateRequest, SelfUpdateStart } from './adapter-types.js';
+import type { BundleManager, InstalledModule, ProfileModule, ProfilePackage, RegistryNotebook, RuntimeStatus, SelfUpdateRequest, SelfUpdateStart } from './adapter-types.js';
 import type { PostResource, RouteHandler, RouteTable } from './http.js';
-import type { PluginSourceOptions, ResolvedPluginSource } from './plugin-source.js';
+import type { PluginSourceOptions, ResolvedPluginSource } from '../contract/plugin-source.js';
 export interface LoggerLike {
     info?(message: string): void;
     warn?(message: string): void;
@@ -16,7 +20,7 @@ export interface ProfilePort {
 }
 export type SupplyPluginSource = ResolvedPluginSource;
 export interface SupplyPackageRoute {
-    readonly kind: 'opencli-plugin' | 'dsh-bundle' | 'neither';
+    readonly kind: PluginPackageKind | 'dsh-bundle' | 'neither';
     readonly pkg?: string;
     readonly pluginName?: string;
 }
@@ -63,6 +67,9 @@ export interface EnvSupplyPort {
         }>;
         readonly version?: string | undefined;
     }): string;
+    libUninstallCommand(options: {
+        readonly need: LibNeed;
+    }): string;
     pluginInstallPlan(options: SupplyPluginInstallOptions): ResolvedPluginSource;
     latestVersion(options: SupplyLatestOptions): Promise<string | undefined>;
     missingReleaseParts(options: SupplyMissingPartsOptions): Promise<readonly string[]>;
@@ -70,10 +77,14 @@ export interface EnvSupplyPort {
     splitNpmSpec(spec: string): SupplyNpmRef | undefined;
 }
 export interface ModulePort {
+    isolatedRoot(): string;
     isolatedHome(): string;
-    cliCatalogPath(): string;
-    vendorPluginsDir(): string;
-    opencliInstallCommand(): string;
+    pluginPackagePrefix?(): string;
+    pluginManifestFile?(): string;
+    cliCatalogPath?(): string;
+    vendorPluginsDir?(): string;
+    runtimeInstallCommand?(): string;
+    afterLibInstall(): void;
     profileDirOf(ctx: DshHostContext): string | null;
     profileModules(dir: string | null): readonly ProfileModule[];
     readInstalledModule(dir: string | null, pkg: string): InstalledModule;
@@ -116,8 +127,10 @@ export interface ProbePreflightInput {
     readonly routes: RouteTable;
     readonly ctx: DshHostContext;
     readonly shell: DshShell;
-    readonly opencliCommand: string;
-    readonly installCommand?: string | undefined;
+    readonly runtimeCommands: Readonly<Record<string, string>>;
+    readonly runtimeCapabilities: RuntimeCapabilities;
+    readonly runtimeCheck?: (() => Promise<RuntimeCheck>) | undefined;
+    readonly runtimeLabel?: string | undefined;
     readonly warmReads: () => readonly (readonly string[])[];
 }
 export interface ProbePort {
@@ -129,9 +142,29 @@ export interface RuntimeSeedOptions {
     readonly corePackageUrl: string;
     readonly log: (message: string) => void;
 }
+export type { RuntimeCapabilities, RuntimeProfile, RuntimeTerms } from '../contract/capabilities.js';
+export interface RuntimeCheck {
+    readonly ok: boolean;
+    readonly detail: string;
+}
+export interface RuntimeCommandSurface {
+    readonly name: string;
+    readonly pluginPrefix: string;
+    invoke(site: string, command?: string): string;
+    help(site: string): string;
+    browser?(verb: readonly string[]): string;
+    background?(command: string, argv: readonly string[]): string;
+    readonly authorHint?: string;
+}
 export interface RuntimePort {
     packageRoot(moduleUrl: string): string;
-    opencliCommand(ctx: DshHostContext): OpencliResolution;
+    capabilities(ctx: DshHostContext): RuntimeCapabilities;
+    profile?(ctx: DshHostContext): RuntimeProfile;
+    commandSurface?(ctx: DshHostContext): RuntimeCommandSurface | undefined;
+    check?(ctx: DshHostContext): Promise<RuntimeCheck>;
+    commands(ctx: DshHostContext): Readonly<Record<string, string>>;
+    runners(ctx: DshHostContext, data: DataReader): Readonly<Record<string, LibRunner>>;
+    health(ctx: DshHostContext): Readonly<Record<string, RuntimeStatus>>;
     seed(ctx: DshHostContext, options: RuntimeSeedOptions): void;
     warnUnwritableRoot(ctx: DshHostContext): void;
 }

package/dist/host/preflight.d.ts

@@ -1,10 +1,11 @@
-export type PreflightStepId = 'toolchain' | 'opencli' | 'bridge' | 'diy' | 'warm';
+export type PreflightStepId = 'toolchain' | 'cli' | 'bridge' | 'runtime' | 'diy' | 'warm';
 export type PreflightStepStatus = 'pending' | 'running' | 'ok' | 'warn' | 'failed';
 export type PreflightFailure = 'permission' | 'network' | 'missing' | 'unknown';
 export type PreflightGuidance = 'install' | 'path' | 'shell';
-export type PreflightBridgeIssue = 'daemon' | 'extension' | 'profile' | 'stale' | 'unknown';
+export type PreflightBridgeIssue = string;
 export interface PreflightStep {
     readonly id: PreflightStepId;
+    readonly label?: string;
     readonly status: PreflightStepStatus;
     readonly detail?: string;
     readonly action?: string;

package/dist/host/profile-create.d.ts

@@ -0,0 +1,18 @@
+import type { PostResource, RouteHandler } from './http.js';
+import type { ProfileCreateApplied, ProfileCreateSnapshot } from '../contract/protocol/profile-create.js';
+export interface ProfileCreateDeps {
+    readonly home: string;
+    readonly self: string;
+    readonly packageRoot: string;
+    readonly runSetup?: ((env: Readonly<Record<string, string>>) => Promise<{
+        ok: boolean;
+        log: string;
+    }>) | undefined;
+}
+export declare function profileCreateSnapshot(deps: ProfileCreateDeps): ProfileCreateSnapshot;
+export declare function profileCreateHandler(deps: ProfileCreateDeps): RouteHandler;
+export declare function profileCreateApply(deps: ProfileCreateDeps, payload: unknown): Promise<ProfileCreateApplied | {
+    ok: false;
+    text: string;
+}>;
+export declare function profileCreateAction(deps: ProfileCreateDeps): PostResource;

package/dist/host/profile-create.js

@@ -0,0 +1,118 @@
+import { existsSync, readFileSync, readdirSync, rmSync } from 'node:fs';
+import { join, resolve, sep } from 'node:path';
+import { quoteShellArg } from './shell-text.js';
+import { PROFILE_CREATE_RESOURCE } from '../contract/protocol/profile-create.js';
+const PROFILE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const BUNDLE = '@dsh-workbench/core';
+function textOf(value) {
+    return typeof value === 'string' ? value : '';
+}
+function profileNames(profilesDir) {
+    try {
+        return readdirSync(profilesDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() || entry.isSymbolicLink())
+            .map((entry) => entry.name)
+            .filter((name) => existsSync(join(profilesDir, name, 'package.json')))
+            .sort((a, b) => a.localeCompare(b));
+    }
+    catch {
+        return [];
+    }
+}
+export function profileCreateSnapshot(deps) {
+    const profiles = profileNames(join(deps.home, 'profiles')).map((name) => ({
+        name,
+        current: name === deps.self,
+        readable: true,
+    }));
+    return { current: deps.self, profiles };
+}
+export function profileCreateHandler(deps) {
+    return () => ({ ok: true, ...profileCreateSnapshot(deps) });
+}
+function inside(base, path) {
+    const root = resolve(base);
+    const target = resolve(path);
+    return target === root ? false : target.startsWith(`${root}${sep}`);
+}
+export async function profileCreateApply(deps, payload) {
+    const body = typeof payload === 'object' && payload !== null ? payload : {};
+    const profile = textOf(body['profile']).trim();
+    const source = textOf(body['source']).trim();
+    const copy = typeof body['copy'] === 'object' && body['copy'] !== null ? body['copy'] : {};
+    const flags = {
+        settings: copy['settings'] === true,
+    };
+    if (!PROFILE_NAME.test(profile))
+        return { ok: false, text: '新工作台的名字不合法：只用字母、数字、点、下划线或短横线' };
+    if (source === '')
+        return { ok: false, text: '先选一个来源 profile' };
+    if (source === profile)
+        return { ok: false, text: '来源不能是新工作台自己' };
+    const profilesDir = join(deps.home, 'profiles');
+    if (!profileNames(profilesDir).includes(source))
+        return { ok: false, text: `没有这个 profile：${source}` };
+    if (existsSync(join(profilesDir, profile)))
+        return { ok: false, text: `已经有一个叫 ${profile} 的 profile` };
+    const targetHome = join(deps.home, profile);
+    if (existsSync(targetHome))
+        return { ok: false, text: `运行时目录已经存在：${targetHome}` };
+    const env = {
+        DSH_HOME: deps.home,
+        DSH_WORKBENCH_HOME: targetHome,
+        WORKBENCH_PROFILE: profile,
+        WORKBENCH_SOURCE_PROFILE: source,
+        WB_CLONE: '1',
+        WB_COPY_SETTINGS: flags.settings ? '1' : '0',
+    };
+    const setup = deps.runSetup;
+    if (setup === undefined) {
+        return { ok: false, text: '这台机器上没有装工作台的脚本入口，建不了新的工作台。' };
+    }
+    const cleanup = () => {
+        try {
+            if (inside(profilesDir, join(profilesDir, profile)))
+                rmSync(join(profilesDir, profile), { recursive: true, force: true });
+            if (inside(deps.home, targetHome))
+                rmSync(targetHome, { recursive: true, force: true });
+        }
+        catch {
+            return;
+        }
+    };
+    const result = await setup(env);
+    if (!result.ok) {
+        cleanup();
+        return { ok: false, text: `创建失败：${result.log.trim().slice(-1200) || 'setup 没给出原因'}` };
+    }
+    try {
+        const manifest = JSON.parse(readFileSync(join(profilesDir, profile, 'package.json'), 'utf8'));
+        const bundles = manifest.dsh?.profile?.bundles;
+        if (!Array.isArray(bundles) || !bundles.includes(BUNDLE)) {
+            cleanup();
+            return { ok: false, text: 'profile 建好了，但工作台 bundle 没被选中；先跑一次 setup 修好它' };
+        }
+    }
+    catch (error) {
+        cleanup();
+        return { ok: false, text: `profile 建好了，但读不了清单：${error instanceof Error ? error.message : String(error)}` };
+    }
+    const copied = Object.entries(flags)
+        .filter(([, on]) => on)
+        .map(([name]) => name);
+    const bin = join(deps.packageRoot, 'bin', 'dsh-workbench');
+    return {
+        ok: true,
+        profile,
+        source,
+        home: targetHome,
+        command: `WORKBENCH_PROFILE=${quoteShellArg(profile)} ${quoteShellArg(bin)}`,
+        copied,
+    };
+}
+export function profileCreateAction(deps) {
+    return {
+        resource: PROFILE_CREATE_RESOURCE,
+        handle: (payload) => profileCreateApply(deps, payload),
+    };
+}

package/dist/host/profile-registries.d.ts

@@ -0,0 +1,10 @@
+import type { RegistryEntry, RegistryNotebook } from './adapter-types.js';
+export declare const REGISTRY_MARKER = "# dsh-workbench \u5199\u7684\uFF1A\u8FD9\u4E00\u884C\u7684\u5305\u53EA\u5728\u8FD9\u4E2A\u6E90\u4E0A\uFF08dsh \u5378\u8F7D\u6CA1\u6709\u6E90\u53C2\u6570\uFF0Cpnpm \u5F97\u95EE\u5F97\u5230\uFF09";
+export declare function sourcesFromLockfile(text: string): readonly RegistryEntry[];
+export interface RegistryConfigMerge {
+    readonly text: string;
+    readonly added: readonly string[];
+}
+export declare function mergeRegistryConfig(text: string, entries: readonly RegistryEntry[]): RegistryConfigMerge;
+export declare function replaceScopeRegistry(text: string, scope: string, registry: string): string;
+export declare function createRegistryNotebook(dir: string | null): RegistryNotebook;