@dsh-workbench/shared 0.3.10 → 1.0.0-beta.0

package/dist/host/plugin-source.js

@@ -1,56 +1,66 @@
 import { quoteShellArg } from './shell-text.js';
-import { npmCacheDir, toolchainOpencliDir, vendorPeerLink, vendorPrefix } from '../host/opencli-runtime.js';
+import { npmCacheDir, toolchainOpencliDir, vendorPeerLink, vendorPrefix } from './paths.js';
 function mergeLines(commands) {
-    return commands
-        .map((item) => item.optional === true ? `(${item.line} || true)` : item.line)
-        .join(" && ");
+    return commands.map((item) => (item.optional === true ? `(${item.line} || true)` : item.line)).join(' && ');
 }
 function envValue(env, name) {
     const value = env[name]?.trim();
-    return value === undefined || value === ""
-        ? { ok: false }
-        : { ok: true, value };
+    return value === undefined || value === '' ? { ok: false } : { ok: true, value };
 }
 export function npmRegistryOf(source, env) {
-    const fromEnv = envValue(env, source.registryEnv);
-    if (fromEnv.ok)
-        return fromEnv;
+    const name = source.registryEnv ?? '';
+    if (name !== '') {
+        const fromEnv = envValue(env, name);
+        if (fromEnv.ok)
+            return fromEnv;
+    }
     const fallback = source.registryDefault?.trim();
-    return fallback === undefined || fallback === ""
-        ? { ok: false }
-        : { ok: true, value: fallback };
+    if (fallback === undefined || fallback === '')
+        return { ok: false, env: name };
+    return { ok: true, value: fallback };
 }
 function installOne(command, spec) {
     const line = `${quoteShellArg(command)} plugin install ${quoteShellArg(spec)}`;
     return { ok: true, commands: [{ line }], line };
 }
+function pluginPackageOf(source, plugin) {
+    if (source.kind === 'npm') {
+        const pkg = source.package?.trim() ?? '';
+        if (pkg !== '')
+            return pkg;
+        return plugin.trim() === '' ? '' : `opencli-plugin-${plugin.trim()}`;
+    }
+    if (source.kind === 'git')
+        return source.url.trim();
+    return '';
+}
 function npmSource(source, env, options) {
     const registry = npmRegistryOf(source, env);
     if (!registry.ok)
-        return { ok: false, problem: "env-missing", env: source.registryEnv };
-    const name = source.package.trim();
-    if (name === "")
-        return { ok: false, problem: "malformed" };
-    const { command = "opencli", plugin = "", version = "latest", mode = "install", } = options;
+        return { ok: false, problem: 'env-missing', env: registry.env };
+    const { command = 'opencli', plugin = '', version = 'latest', mode = 'install' } = options;
+    const name = pluginPackageOf(source, plugin);
+    if (name === '')
+        return { ok: false, problem: 'malformed' };
     const prefix = vendorPrefix();
     const dirInPrefix = `${prefix}/node_modules/${name}`;
     const peer = vendorPeerLink();
     const commands = [
         {
             line: [
-                "npm i",
+                'npm i',
                 `--prefix ${quoteShellArg(prefix)}`,
                 quoteShellArg(`${name}@${version}`),
                 `--registry ${quoteShellArg(registry.value)}`,
                 `--cache ${quoteShellArg(npmCacheDir())}`,
-            ].join(" "),
+            ].join(' '),
         },
         {
             line: `rm -rf ${quoteShellArg(peer.dir)} && mkdir -p ${quoteShellArg(peer.parent)} && ln -s ${quoteShellArg(toolchainOpencliDir())} ${quoteShellArg(peer.dir)}`,
         },
     ];
-    if (mode === "install") {
-        if (plugin !== "") {
+    if (mode === 'install') {
+        if (plugin !== '') {
             commands.push({
                 line: `${quoteShellArg(command)} plugin uninstall ${quoteShellArg(plugin)}`,
                 optional: true,
@@ -64,18 +74,18 @@ function npmSource(source, env, options) {
 }
 export function resolvePluginSource(source, env, options = {}) {
     if (source === undefined)
-        return { ok: false, problem: "not-declared" };
-    const command = options.command ?? "opencli";
-    if (source.kind === "git") {
+        return { ok: false, problem: 'not-declared' };
+    const command = options.command ?? 'opencli';
+    if (source.kind === 'git') {
         const url = source.url.trim();
-        return url === ""
-            ? { ok: false, problem: "malformed" }
-            : installOne(command, url);
+        return url === '' ? { ok: false, problem: 'malformed' } : installOne(command, url);
     }
-    if (source.kind === "npm")
+    if (source.kind === 'npm')
         return npmSource(source, env, options);
-    const value = envValue(env, source.env);
-    return value.ok
-        ? installOne(command, value.value)
-        : { ok: false, problem: "env-missing", env: source.env };
+    const value = source.env === undefined ? { ok: false } : envValue(env, source.env);
+    if (value.ok)
+        return installOne(command, value.value);
+    if (source.path !== undefined && source.path.trim() !== '')
+        return installOne(command, source.path.trim());
+    return { ok: false, problem: 'env-missing', env: source.env ?? '' };
 }

package/dist/host/plugin.d.ts

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

package/dist/host/plugin.js

@@ -0,0 +1,39 @@
+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;
+}
+function isCommandFile(name) {
+    if (name.endsWith('.d.ts') || name.endsWith('.test.ts'))
+        return false;
+    if (name.endsWith('.d.js'))
+        return false;
+    return name.endsWith('.ts') || name.endsWith('.js');
+}
+function pluginManifestOf(dir) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(dir, OPENCLI_MANIFEST_FILE), 'utf8'));
+        if (Array.isArray(parsed))
+            return undefined;
+        return asRecord(parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function hasCommandFile(dir) {
+    try {
+        return readdirSync(dir).some(isCommandFile);
+    }
+    catch {
+        return false;
+    }
+}
+export function pluginAt(dir) {
+    const manifest = pluginManifestOf(dir);
+    if (manifest === undefined || !hasCommandFile(dir))
+        return undefined;
+    const name = manifest.name;
+    return typeof name === 'string' && name.trim() !== '' ? { name: name.trim() } : {};
+}

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

@@ -0,0 +1,191 @@
+import type { DshHostContext, DshShell } from '../api/dsh.js';
+import type { LibNeed, SupplySource } from '../contract/needs.js';
+import type { NeedProbeInput, UnitCapability } from '../contract/unit-capability.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 { PostResource, RouteHandler, RouteTable } from './http.js';
+import type { PluginSourceOptions, ResolvedPluginSource } from './plugin-source.js';
+export interface LoggerLike {
+    info?(message: string): void;
+    warn?(message: string): void;
+}
+export interface ProfilePort {
+    dirOf(ctx: DshHostContext): string | null;
+    dshPlugins(ctx: DshHostContext): RouteHandler;
+    selfUpdateView(root: string, profile: string): WorkbenchSelfUpdate | undefined;
+}
+export type SupplyPluginSource = ResolvedPluginSource;
+export interface SupplyPackageRoute {
+    readonly kind: 'opencli-plugin' | 'dsh-bundle' | 'neither';
+    readonly pkg?: string;
+    readonly pluginName?: string;
+}
+export interface SupplyRelease {
+    readonly installed?: string;
+    readonly latest?: string;
+    readonly missing?: readonly string[];
+}
+export interface SupplyNpmRef {
+    readonly name: string;
+    readonly version?: string;
+}
+export interface SupplyPluginInstallOptions {
+    readonly spec: string;
+    readonly command: string;
+    readonly registry?: string | undefined;
+    readonly pluginName?: string | undefined;
+}
+export interface SupplyLatestOptions {
+    readonly shell: DshShell;
+    readonly name: string;
+    readonly registry: string;
+    readonly force?: boolean;
+}
+export interface SupplyMissingPartsOptions {
+    readonly shell: DshShell;
+    readonly registry: string;
+    readonly version: string;
+    readonly force?: boolean;
+}
+export interface SupplyProbeReleaseOptions {
+    readonly shell: DshShell;
+    readonly package: string;
+    readonly registry?: string | undefined;
+    readonly force?: boolean;
+}
+export interface EnvSupplyPort {
+    resolvePluginSource(source: SupplySource | undefined, env: Readonly<Record<string, string | undefined>>, options?: PluginSourceOptions): ResolvedPluginSource;
+    libInstallCommand(options: {
+        readonly need: LibNeed;
+        readonly source: Extract<SupplySource, {
+            kind: 'npm';
+        }>;
+        readonly version?: string | undefined;
+    }): string;
+    pluginInstallPlan(options: SupplyPluginInstallOptions): ResolvedPluginSource;
+    latestVersion(options: SupplyLatestOptions): Promise<string | undefined>;
+    missingReleaseParts(options: SupplyMissingPartsOptions): Promise<readonly string[]>;
+    probeRelease(options: SupplyProbeReleaseOptions): Promise<SupplyRelease | undefined>;
+    splitNpmSpec(spec: string): SupplyNpmRef | undefined;
+}
+export interface ModulePort {
+    isolatedHome(): string;
+    cliCatalogPath(): string;
+    vendorPluginsDir(): string;
+    opencliInstallCommand(): string;
+    profileDirOf(ctx: DshHostContext): string | null;
+    profileModules(dir: string | null): readonly ProfileModule[];
+    readInstalledModule(dir: string | null, pkg: string): InstalledModule;
+    readProfilePackage(dir: string | null, pkg: string): ProfilePackage | undefined;
+    readBundleManager(ctx: DshHostContext): BundleManager | undefined;
+    createRegistryNotebook(dir: string | null): RegistryNotebook;
+    declarationGaps(dir: string | null): readonly {
+        readonly pkg: string;
+    }[] | undefined;
+    moduleDeclarationOf(dir: string | null, pkg: string): unknown;
+    registryDeclarationOf(options: {
+        readonly shell: DshShell;
+        readonly name: string;
+        readonly registry: string;
+        readonly force?: boolean;
+    }): Promise<unknown>;
+    pathDeclarationOf(spec: string): unknown;
+    declarationRefusalOf(name: string, raw: unknown): readonly string[];
+    refusalReason(): string;
+    packageRouteOf(options: {
+        readonly spec: string;
+        readonly shell?: DshShell | undefined;
+        readonly registry?: string | undefined;
+        readonly force?: boolean;
+    }): Promise<SupplyPackageRoute | undefined>;
+    isNewerVersion(left: string, right: string): boolean;
+    startSelfUpdate(request: SelfUpdateRequest, onError: (message: string) => void): SelfUpdateStart;
+}
+export interface SupplyPort extends EnvSupplyPort, ModulePort {
+    readonly env: EnvSupplyPort;
+    readonly modules: ModulePort;
+}
+export interface ProbeUnitsOptions {
+    readonly shell: DshShell;
+    readonly runtimeCommands: Readonly<Record<string, string>>;
+    readonly units: readonly NeedProbeInput[];
+    readonly force?: boolean;
+}
+export interface ProbePreflightInput {
+    readonly routes: RouteTable;
+    readonly ctx: DshHostContext;
+    readonly shell: DshShell;
+    readonly opencliCommand: string;
+    readonly installCommand?: string | undefined;
+    readonly warmReads: () => readonly (readonly string[])[];
+}
+export interface ProbePort {
+    probeUnits(options: ProbeUnitsOptions): Promise<UnitCapability[]>;
+    registerPreflight(input: ProbePreflightInput): void;
+    declaredPluginCommands(profileDir: string | null): ReadonlyMap<string, ReadonlySet<string>>;
+}
+export interface RuntimeSeedOptions {
+    readonly corePackageUrl: string;
+    readonly log: (message: string) => void;
+}
+export interface RuntimePort {
+    packageRoot(moduleUrl: string): string;
+    opencliCommand(ctx: DshHostContext): OpencliResolution;
+    seed(ctx: DshHostContext, options: RuntimeSeedOptions): void;
+    warnUnwritableRoot(ctx: DshHostContext): void;
+}
+export interface PluginDeclarationSource {
+    readonly pkg: string;
+    readonly declaration: unknown;
+}
+export interface PluginRowRef {
+    readonly id: string;
+    readonly pkg: string;
+    readonly name?: string | undefined;
+}
+export interface PluginRowsSource {
+    listPlugins(workspace: string | null): readonly PluginRowRef[];
+    subscribe?(listener: () => void): () => void;
+}
+export interface PluginUnitsPort {
+    refresh(options?: {
+        readonly force?: boolean;
+    }): Promise<unknown>;
+    touch(): void;
+    report(): unknown;
+    dispose(): void;
+}
+export interface PluginUnitsInput {
+    readonly registry: {
+        registerPlugin(face: unknown): () => void;
+    };
+    readonly rows: () => readonly PluginRowRef[];
+    readonly declared: (plugin: string) => ReadonlySet<string>;
+    readonly toolNames?: () => ReadonlySet<string>;
+    readonly logger?: LoggerLike | undefined;
+}
+export interface PluginSurface {
+    declarationLookup(profileDir: string | null): (unit: string) => PluginDeclarationSource | undefined;
+    createUnits(input: PluginUnitsInput): PluginUnitsPort;
+}
+export interface ConfigSyncInput {
+    readonly home: string;
+    readonly self: string;
+    readonly profileDir: string | null;
+    readonly reconcile?: (() => Promise<boolean | void>) | undefined;
+}
+export interface ProfileCreateInput {
+    readonly home: string;
+    readonly self: string;
+    readonly packageRoot: string;
+    readonly runSetup?: ((env: Readonly<Record<string, string>>) => Promise<{
+        ok: boolean;
+        log: string;
+    }>) | undefined;
+}
+export interface HostActions {
+    configSyncHandler(input: ConfigSyncInput): RouteHandler;
+    profileCreateHandler(input: ProfileCreateInput): RouteHandler;
+    configSyncAction(input: ConfigSyncInput): PostResource;
+    profileCreateAction(input: ProfileCreateInput): PostResource;
+}

package/dist/host/port-types.js

@@ -0,0 +1 @@
+export {};

package/dist/host/preflight.d.ts

@@ -0,0 +1,28 @@
+export type PreflightStepId = 'toolchain' | 'opencli' | 'bridge' | '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 interface PreflightStep {
+    readonly id: PreflightStepId;
+    readonly status: PreflightStepStatus;
+    readonly detail?: string;
+    readonly action?: string;
+    readonly command?: string;
+}
+export interface PreflightDiyGap {
+    readonly rows: readonly string[];
+    readonly detail: string;
+    readonly command: string;
+}
+export interface PreflightSnapshot {
+    readonly phase: 'idle' | 'checking' | 'installing' | 'ready' | 'failed';
+    readonly steps: readonly PreflightStep[];
+    readonly at: number;
+    readonly error?: string;
+    readonly failure?: PreflightFailure;
+    readonly guidance?: PreflightGuidance;
+    readonly bridgeIssues?: readonly PreflightBridgeIssue[];
+    readonly diyGap?: PreflightDiyGap;
+    readonly canWakeBrowser?: boolean;
+}

package/dist/host/preflight.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+import type { DshHostContext } from '../api/dsh.js';
+import type { ProfilePort } from './port-types.js';
+export type { ProfilePort } from './port-types.js';
+export declare function profilePortOf(ctx: DshHostContext): ProfilePort;

package/dist/host/profile-port.js

@@ -0,0 +1,4 @@
+import { adaptersOf } from './adapters.js';
+export function profilePortOf(ctx) {
+    return adaptersOf(ctx).profile;
+}

package/dist/host/provision.d.ts

@@ -1,6 +1,6 @@
-import type { ProvisionAction } from '../api/workbench-contract.js';
+import type { ProvisionAction } from '../contract/workbench-contract.js';
 export type { ProvisionAction };
-export declare const PROVISION_ACTIONS: readonly ["install", "update", "uninstall", "install-bundle", "update-bundle", "remove-bundle", "cancel-install", "update-dependency", "update-plugin", "uninstall-plugin", "update-workbench"];
+export declare const PROVISION_ACTIONS: readonly ["install", "update", "uninstall", "install-bundle", "install-version", "update-bundle", "remove-bundle", "cancel-install", "update-dependency", "update-plugin", "uninstall-plugin", "update-workbench"];
 export declare const DEPENDENCY_ACTIONS: readonly ["update-dependency"];
 export declare function isDependencyAction(action: ProvisionAction): action is (typeof DEPENDENCY_ACTIONS)[number];
 export type ProvisionTarget = 'unit' | 'id' | 'spec' | 'name' | 'requestId';

package/dist/host/provision.js

@@ -3,6 +3,7 @@ export const PROVISION_ACTIONS = [
     'update',
     'uninstall',
     'install-bundle',
+    'install-version',
     'update-bundle',
     'remove-bundle',
     'cancel-install',
@@ -20,7 +21,7 @@ void ALL_ACTIONS_COVERED;
 export function provisionTargetOf(action) {
     if (action === 'update-dependency')
         return 'id';
-    if (action === 'install-bundle')
+    if (action === 'install-bundle' || action === 'install-version')
         return 'spec';
     if (action === 'remove-bundle')
         return 'name';
@@ -51,7 +52,7 @@ function stringsOf(value) {
 function requestOf(action, value) {
     if (action === 'update-dependency')
         return { action, id: value };
-    if (action === 'install-bundle')
+    if (action === 'install-bundle' || action === 'install-version')
         return { action, spec: value };
     if (action === 'remove-bundle')
         return { action, name: value };
@@ -79,8 +80,9 @@ export function parseProvisionBody(body) {
     if (typeof value !== 'string' || value.trim() === '') {
         return { ok: false, code: TARGET_CODE[target], message: `缺少 ${target}` };
     }
-    if (wanted !== 'install-bundle')
+    if (wanted !== 'install-bundle' && wanted !== 'install-version') {
         return { ok: true, request: requestOf(wanted, value.trim()) };
+    }
     const registry = typeof raw.registry === 'string' && raw.registry.trim() !== '' ? raw.registry.trim() : undefined;
     const approvedBuilds = stringsOf(raw.approvedBuilds);
     const requestId = typeof raw.requestId === 'string' && raw.requestId.trim() !== '' ? raw.requestId.trim() : undefined;

package/dist/host/recipe-rules.d.ts

@@ -0,0 +1,5 @@
+import type { CallOverrides } from '../contract/data.js';
+export declare const DEFAULT_RECIPE_MAX_BYTES: number;
+export declare const MAX_RECIPE_CALLS = 8;
+export declare function recipeProblemOf(recipe: unknown, overrides?: CallOverrides): string | undefined;
+export declare function callsProblemOf(recipe: unknown, calls: unknown): string | undefined;