@dsh-workbench/shared 0.1.0

package/src/host/http.ts

@@ -0,0 +1,311 @@
+import type { DshHostContext, DshRequest, DshResponse } from '../api/dsh.js';
+import { unitFactScope } from '../api/facts.js';
+import { ACTIONS_PREFIX, API_PREFIX, PLUGIN_ID, PREFS_PREFIX, PROVISION_PREFIX } from '../config/constants.js';
+import {
+  isDependencyAction,
+  PROVISION_ACTIONS,
+  type ProvisionAction,
+  type ProvisionHandler,
+  type ProvisionRequest,
+} from './provision';
+import { WorkbenchDataError } from '../host/opencli.js';
+import { writeResultForClient } from './write-result';
+
+export type RouteHandler = (search: URLSearchParams) => Promise<unknown> | unknown;
+
+export type RouteTable = Record<string, RouteHandler>;
+
+const MAX_PREFS_BODY_BYTES = 8 * 1024;
+
+const PROVISION_FACTS = ['capability', 'panels'] as const;
+
+function provisionFacts(provision: ProvisionHandler, request: ProvisionRequest): readonly string[] {
+  const scopes = (provision.affectedUnits?.(request) ?? []).map(unitFactScope);
+  return [...PROVISION_FACTS, ...scopes];
+}
+
+function sendJson(res: DshResponse, status: number, body: unknown): void {
+  res.statusCode = status;
+  res.setHeader('content-type', 'application/json; charset=utf-8');
+  res.setHeader('cache-control', 'no-store');
+  res.end(JSON.stringify(body));
+}
+
+function toErrorPayload(error: unknown): Record<string, unknown> {
+  if (error instanceof WorkbenchDataError) {
+    return {
+      code: error.code,
+      message: error.message,
+      ...(error.detail === undefined ? {} : { detail: error.detail }),
+      ...(error.hint === undefined ? {} : { hint: error.hint }),
+      ...(error.helpUrl === undefined ? {} : { helpUrl: error.helpUrl }),
+      ...(error.project === undefined ? {} : { project: error.project }),
+    };
+  }
+  return { code: 'internal', message: error instanceof Error ? error.message : String(error) };
+}
+
+export function flag(search: URLSearchParams, name: string): boolean {
+  const raw = search.get(name);
+  if (raw === null) return false;
+  return raw === '' || raw === '1' || raw.toLowerCase() === 'true';
+}
+
+export function param(search: URLSearchParams, name: string): string | undefined {
+  const raw = search.get(name);
+  return raw === null || raw === '' ? undefined : raw;
+}
+
+export function registerApi(ctx: DshHostContext, routes: RouteTable): () => void {
+  return ctx.webServer.register({
+    kind: 'prefix',
+    path: API_PREFIX,
+    handler: async (req: DshRequest, res: DshResponse) => {
+      const raw = req.url ?? '/';
+      const cut = raw.indexOf('?');
+      const pathname = cut === -1 ? raw : raw.slice(0, cut);
+      const search = new URLSearchParams(cut === -1 ? '' : raw.slice(cut + 1));
+      const route = pathname.slice(API_PREFIX.length).replace(/^\//, '');
+
+      if (req.method !== 'GET') {
+        sendJson(res, 405, { ok: false, error: { code: 'method-not-allowed', message: '只支持 GET' } });
+        return;
+      }
+
+      const handler = Object.prototype.hasOwnProperty.call(routes, route) ? routes[route] : undefined;
+      if (handler === undefined) {
+        sendJson(res, 404, { ok: false, error: { code: 'not-found', message: `没有这个接口：${route}` } });
+        return;
+      }
+
+      try {
+        sendJson(res, 200, await handler(search));
+      } catch (error) {
+        if (error instanceof WorkbenchDataError) {
+          sendJson(res, 200, { ok: false, error: toErrorPayload(error) });
+          return;
+        }
+        ctx.logger?.warn?.(`[dsh-workbench] 路由 ${route} 失败：${String(error)}`);
+        sendJson(res, 500, { ok: false, error: toErrorPayload(error) });
+      }
+    },
+  });
+}
+
+export function registerProvision(
+  ctx: DshHostContext,
+  provision: ProvisionHandler,
+  log?: { bump(facts: readonly string[]): unknown } | undefined,
+): () => void {
+  return ctx.webServer.register({
+    kind: 'prefix',
+    path: PROVISION_PREFIX,
+    handler: async (req: DshRequest, res: DshResponse) => {
+      if (req.method !== 'POST') {
+        sendJson(res, 405, { ok: false, error: { code: 'method-not-allowed', message: '机器供给只支持 POST' } });
+        return;
+      }
+      let payload: unknown;
+      try {
+        const raw = await readBoundedBody(req);
+        if (raw === null) {
+          sendJson(res, 413, { ok: false, error: { code: 'body-too-large', message: '请求体太大' } });
+          return;
+        }
+        payload = raw === '' ? {} : JSON.parse(raw);
+      } catch (error) {
+        sendJson(res, 400, { ok: false, error: { code: 'bad-json', message: String(error) } });
+        return;
+      }
+
+      const body =
+        typeof payload === 'object' && payload !== null
+          ? (payload as { action?: unknown; unit?: unknown; id?: unknown })
+          : {};
+      const action = body.action;
+      if (typeof action !== 'string' || !PROVISION_ACTIONS.includes(action as ProvisionAction)) {
+        sendJson(res, 400, {
+          ok: false,
+          error: {
+            code: 'workbench/bad-action',
+            message: `不认识的 action：${String(action)}（可用：${PROVISION_ACTIONS.join(' / ')}）`,
+          },
+        });
+        return;
+      }
+      const wanted = action as ProvisionAction;
+      const target = isDependencyAction(wanted) ? body.id : body.unit;
+      if (typeof target !== 'string' || target.trim() === '') {
+        sendJson(res, 400, {
+          ok: false,
+          error: {
+            code: isDependencyAction(wanted) ? 'workbench/no-id' : 'workbench/no-unit',
+            message: isDependencyAction(wanted) ? '缺少 id' : '缺少 unit',
+          },
+        });
+        return;
+      }
+
+      const key = target.trim();
+      const request: ProvisionRequest = isDependencyAction(wanted)
+        ? { action: wanted, id: key }
+        : { action: wanted, unit: key };
+      try {
+        const result = await provision.handle(request);
+        log?.bump(provisionFacts(provision, request));
+        sendJson(res, 200, result);
+      } catch (error) {
+        log?.bump(provisionFacts(provision, request));
+        sendJson(res, 200, { ok: false, error: toErrorPayload(error) });
+      }
+    },
+  });
+}
+
+export interface PostResource {
+  readonly resource: string;
+  readonly unit?: string;
+  handle(payload: unknown): Promise<unknown> | unknown;
+}
+
+export interface PostWrite {
+  readonly args: unknown;
+  readonly result: unknown;
+}
+
+function registerPost(
+  ctx: DshHostContext,
+  options: {
+    readonly prefix: string;
+    readonly what: string;
+    readonly resources: readonly PostResource[];
+    readonly refusedCode: string;
+    readonly wrote?: ((resource: string, write: PostWrite) => void) | undefined;
+  },
+): () => void {
+  const { prefix, what, resources, refusedCode, wrote } = options;
+  const table = new Map(resources.map((item) => [item.resource, item.handle] as const));
+  return ctx.webServer.register({
+    kind: 'prefix',
+    path: prefix,
+    handler: async (req: DshRequest, res: DshResponse) => {
+      if (req.method !== 'POST') {
+        sendJson(res, 405, { ok: false, error: { code: 'method-not-allowed', message: `${what}只支持 POST` } });
+        return;
+      }
+
+      const raw = await readBoundedBody(req);
+      if (raw === null) {
+        sendJson(res, 413, { ok: false, error: { code: 'payload-too-large', message: '请求体过大' } });
+        return;
+      }
+
+      let payload: unknown;
+      try {
+        payload = raw === '' ? {} : JSON.parse(raw);
+      } catch {
+        sendJson(res, 400, { ok: false, error: { code: 'bad-json', message: '请求体不是 JSON' } });
+        return;
+      }
+
+      const requested = (req.url ?? '/').slice(prefix.length).replace(/^\//, '').split('?')[0] ?? '';
+      const handle = table.get(requested);
+      if (handle === undefined) {
+        sendJson(res, 404, { ok: false, error: { code: 'not-found', message: `没有这个${what}资源：${requested}` } });
+        return;
+      }
+      try {
+        const result = await handle(payload);
+        wrote?.(requested, { args: payload, result });
+        sendJson(res, 200, writeResultForClient(result, refusedCode));
+      } catch (error) {
+        sendJson(res, 200, { ok: false, error: toErrorPayload(error) });
+      }
+    },
+  });
+}
+
+async function readBoundedBody(req: DshRequest): Promise<string | null> {
+  if (typeof req[Symbol.asyncIterator] !== 'function') return '';
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  for await (const chunk of req as AsyncIterable<Uint8Array>) {
+    size += chunk.byteLength;
+    if (size > MAX_PREFS_BODY_BYTES) return null;
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+export function changesHandler(log: {
+  epoch(): string;
+  since(rev: number): { rev: number; facts: readonly string[] };
+}): RouteHandler {
+  return (search) => ({ ok: true, epoch: log.epoch(), ...log.since(Number(param(search, 'since') ?? 0) || 0) });
+}
+
+export function preflightHandler(preflight: {
+  run(options?: { force?: boolean }): Promise<unknown>;
+  snapshot(): unknown;
+}): RouteHandler {
+  return (search) => {
+    void preflight.run({ force: flag(search, 'force') });
+    return { ok: true, ...(preflight.snapshot() as Record<string, unknown>) };
+  };
+}
+
+export function capabilityHandler(
+  probe: (unit: string | undefined, force: boolean) => Promise<unknown> | unknown,
+): RouteHandler {
+  return async (search) => {
+    const unit = param(search, 'unit');
+    const result = await probe(unit, flag(search, 'force'));
+    if (result === undefined) {
+      return { ok: false, error: { code: 'workbench/unknown-unit', message: `没有这个单元：${unit}` } };
+    }
+    return { ok: true, ...(result as Record<string, unknown>) };
+  };
+}
+
+export function healthHandler(ctx: DshHostContext): RouteHandler {
+  return () => {
+    const profile = ctx.get<{ dir?: string }>('profileContext');
+    const dir = profile?.dir;
+    return {
+      ok: true,
+      plugin: PLUGIN_ID,
+      profile: dir === undefined ? null : dir.split('/').pop(),
+      profileDir: dir ?? null,
+      pid: process.pid,
+      now: new Date().toISOString(),
+    };
+  };
+}
+
+export function registerPrefs(
+  ctx: DshHostContext,
+  resources: readonly PostResource[],
+  wrote?: ((resource: string, write: PostWrite) => void) | undefined,
+): () => void {
+  return registerPost(ctx, {
+    prefix: PREFS_PREFIX,
+    what: '偏好写',
+    refusedCode: 'write-refused',
+    resources,
+    ...(wrote === undefined ? {} : { wrote }),
+  });
+}
+
+export function registerActions(
+  ctx: DshHostContext,
+  resources: readonly PostResource[],
+  wrote?: ((resource: string, write: PostWrite) => void) | undefined,
+): () => void {
+  return registerPost(ctx, {
+    prefix: ACTIONS_PREFIX,
+    what: '动作',
+    refusedCode: 'action-refused',
+    resources,
+    ...(wrote === undefined ? {} : { wrote }),
+  });
+}

package/src/host/long-task.ts

@@ -0,0 +1,235 @@
+import { runsRouteOf, type LongTaskStatus, type LongTaskStep } from '../api/long-task.js';
+
+const LIVE: ReadonlySet<string> = new Set<LongTaskStatus>(['running', 'needs-login']);
+
+const RECENT_MS = 10 * 60 * 1000;
+
+export interface LongTaskBase {
+  readonly id: string;
+  readonly workspace: string;
+  readonly target: string;
+  readonly status: LongTaskStatus;
+  readonly step: string;
+  readonly steps: readonly string[];
+  readonly loginUrl?: string | undefined;
+  readonly why?: string | undefined;
+  readonly startedAt: string;
+  readonly at: string;
+}
+
+export interface LongTaskStart {
+  readonly workspace: string;
+  readonly target: string;
+  readonly payload?: unknown;
+}
+
+export interface LongTaskChange<S extends LongTaskBase> {
+  readonly kind: 'start' | 'step' | 'settle';
+  readonly snapshot: S;
+  readonly step?: LongTaskStep | undefined;
+}
+
+export interface LongTaskDeps<S extends LongTaskBase> {
+  readonly run: (options: {
+    readonly payload: unknown;
+    readonly onStep: (step: LongTaskStep) => void;
+  }) => Promise<unknown>;
+  readonly step?: ((step: LongTaskStep, current: S) => Partial<S>) | undefined;
+  readonly outcome?: ((result: unknown, current: S) => Partial<S>) | undefined;
+  readonly view: (snapshot: S) => Readonly<Record<string, unknown>>;
+  readonly now?: (() => string) | undefined;
+  readonly nextId?: (() => string) | undefined;
+  readonly facts?: ((change: LongTaskChange<S>) => readonly string[] | undefined) | undefined;
+  readonly recentMs?: number | undefined;
+}
+
+export interface LongTaskRegistry<S extends LongTaskBase> {
+  start(options: LongTaskStart): S;
+  snapshot(id: string): S | null;
+  active(workspace: string, target: string): S | null;
+  current(workspace: string): readonly Readonly<Record<string, unknown>>[];
+  onChange(listener: (change: LongTaskChange<S>) => void): () => void;
+}
+
+export function createLongTaskRegistry<S extends LongTaskBase>(deps: LongTaskDeps<S>): LongTaskRegistry<S> {
+  const runs = new Map<string, LongTaskBase>();
+  const now = deps.now ?? (() => new Date().toISOString());
+  let counter = 0;
+  const nextId = deps.nextId ?? (() => `run-${Date.now()}-${(counter += 1)}`);
+  const recentMs = deps.recentMs ?? RECENT_MS;
+  const listeners = new Set<(change: LongTaskChange<S>) => void>();
+
+  const notify = (change: LongTaskChange<S>): void => {
+    for (const listener of [...listeners]) {
+      try {
+        listener(change);
+      } catch {
+      }
+    }
+  };
+
+  const patch = (id: string, next: Partial<LongTaskBase>, change: Omit<LongTaskChange<S>, 'snapshot'>): void => {
+    const current = runs.get(id);
+    if (current === undefined) return;
+    const patched = { ...current, ...next, at: now() };
+    runs.set(id, patched);
+    notify({ ...change, snapshot: patched as S });
+  };
+
+  return {
+    active(workspace, target) {
+      for (const snapshot of runs.values()) {
+        if (snapshot.workspace !== workspace || snapshot.target !== target) continue;
+        if (snapshot.status === 'running' || snapshot.status === 'needs-login') return snapshot as S;
+      }
+      return null;
+    },
+
+    current(workspace) {
+      const floor = Date.parse(now()) - recentMs;
+      const newest = new Map<string, LongTaskBase>();
+      for (const snapshot of runs.values()) {
+        if (snapshot.workspace !== workspace) continue;
+        newest.set(snapshot.target, snapshot);
+      }
+      return [...newest.values()]
+        .filter(
+          (snapshot) => LIVE.has(snapshot.status) || Date.parse(snapshot.at) >= floor,
+        )
+        .reverse()
+        .map((snapshot) => deps.view(snapshot as S));
+    },
+
+    start(options) {
+      const running = this.active(options.workspace, options.target);
+      if (running !== null) return running;
+      const id = nextId();
+      const startedAt = now();
+      runs.set(id, {
+        id,
+        workspace: options.workspace,
+        target: options.target,
+        status: 'running',
+        step: '',
+        steps: [],
+        startedAt,
+        at: startedAt,
+      });
+      notify({ kind: 'start', snapshot: runs.get(id) as S });
+
+      const onStep = (step: LongTaskStep): void => {
+        const current = runs.get(id);
+        if (current === undefined) return;
+        const steps = [...current.steps, `${step.kind === 'fail' ? '✗ ' : ''}${step.text}`].slice(-20);
+        const extra = deps.step?.(step, current as S) ?? {};
+        if (step.loginUrl !== undefined) {
+          patch(
+            id,
+            { ...extra, status: 'needs-login', step: step.text, steps, loginUrl: step.loginUrl },
+            { kind: 'step', step },
+          );
+          return;
+        }
+        patch(
+          id,
+          {
+            ...extra,
+            status: current.status === 'needs-login' ? 'running' : current.status,
+            step: step.text,
+            steps,
+            ...(current.status === 'needs-login' ? { loginUrl: undefined } : {}),
+          },
+          { kind: 'step', step },
+        );
+      };
+
+      void deps
+        .run({ payload: options.payload, onStep })
+        .then((result) => {
+          const current = runs.get(id);
+          patch(
+            id,
+            { status: 'ok', ...(deps.outcome?.(result, current as S) ?? {}), loginUrl: undefined },
+            { kind: 'settle' },
+          );
+        })
+        .catch((error: unknown) => {
+          patch(
+            id,
+            {
+              status: 'failed',
+              why: error instanceof Error ? error.message : String(error),
+              loginUrl: undefined,
+            },
+            { kind: 'settle' },
+          );
+        });
+
+      return runs.get(id) as S;
+    },
+
+    snapshot(id) {
+      return (runs.get(id) as S | undefined) ?? null;
+    },
+
+    onChange(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+  };
+}
+
+function isRegistry(value: unknown): value is LongTaskRegistry<LongTaskBase> {
+  if (typeof value !== 'object' || value === null) return false;
+  const candidate = value as Partial<LongTaskRegistry<LongTaskBase>>;
+  return (
+    typeof candidate.start === 'function' &&
+    typeof candidate.current === 'function' &&
+    typeof candidate.snapshot === 'function' &&
+    typeof candidate.onChange === 'function'
+  );
+}
+
+export function sharedLongTaskRegistry<S extends LongTaskBase>(
+  scope: string,
+  key: string,
+  deps: LongTaskDeps<S>,
+): LongTaskRegistry<S> {
+  const store = globalThis as unknown as Record<symbol, LongTaskRegistry<LongTaskBase> | undefined>;
+  const slot = Symbol.for(`dsh-workbench:long-task:${scope}:${key}`);
+  const existing = store[slot];
+  if (existing !== undefined && isRegistry(existing)) return existing as unknown as LongTaskRegistry<S>;
+  const created = createLongTaskRegistry(deps);
+  store[slot] = created;
+  return created;
+}
+
+export interface LongTaskHost {
+  create<S extends LongTaskBase>(options: { readonly key: string } & LongTaskDeps<S>): LongTaskRegistry<S>;
+}
+
+export function createLongTaskHost(options: {
+  readonly scope: string;
+  readonly unit: string;
+  readonly bump: (facts: readonly string[]) => void;
+}): { readonly host: LongTaskHost; dispose(): void } {
+  const offs: Array<() => void> = [];
+  return {
+    host: {
+      create(createOptions) {
+        const { key, facts, ...deps } = createOptions;
+        const registry = sharedLongTaskRegistry(options.scope, `${options.unit}:${key}`, deps);
+        offs.push(
+          registry.onChange((change) => {
+            const named = [runsRouteOf(options.unit), ...(facts?.(change) ?? [])];
+            options.bump([...new Set(named)]);
+          }),
+        );
+        return registry;
+      },
+    },
+    dispose() {
+      for (const off of offs.splice(0)) off();
+    },
+  };
+}

package/src/host/opencli-runtime.ts

@@ -0,0 +1,66 @@
+import { OPENCLI_PIN } from '../config/constants.js';
+import type { UnitLibNeed } from '../api/unit.js';
+import { quoteShellArg } from '../lib/text.js';
+
+import { dshHome } from './data-root';
+
+export { dshHome };
+
+export function isolatedRoot(): string {
+  return `${dshHome()}/workbench/opencli`;
+}
+
+export function isolatedHome(): string {
+  return `${isolatedRoot()}/home`;
+}
+
+export const OPENCLI_NPM_PACKAGE = '@jackwener/opencli';
+
+export function toolchainDir(): string {
+  return `${isolatedRoot()}/toolchain`;
+}
+
+export function toolchainOpencliDir(): string {
+  return `${toolchainDir()}/node_modules/${OPENCLI_NPM_PACKAGE}`;
+}
+
+export function vendorPrefix(): string {
+  return `${isolatedRoot()}/plugins-npm`;
+}
+
+export function vendorPeerLink(): { readonly dir: string; readonly parent: string } {
+  const base = `${vendorPrefix()}/node_modules`;
+  const [scope] = OPENCLI_NPM_PACKAGE.split('/');
+  return { dir: `${base}/${OPENCLI_NPM_PACKAGE}`, parent: `${base}/${scope}` };
+}
+
+export function npmCacheDir(): string {
+  return `${isolatedRoot()}/npm-cache`;
+}
+
+export function isolatedCommand(): string {
+  return `${isolatedRoot()}/bin/opencli`;
+}
+
+export function libsPrefix(): string {
+  return `${isolatedRoot()}/libs`;
+}
+
+export function libDir(name: string): string {
+  return `${libsPrefix()}/node_modules/${name}`;
+}
+
+export function libInstallCommand(options: {
+  readonly need: UnitLibNeed;
+  readonly version?: string | undefined;
+}): string {
+  const { need, version } = options;
+  const registry =
+    process.env[need.registryEnv]?.trim() || need.registryDefault;
+  const spec = version ?? need.version ?? 'latest';
+  return `npm i --prefix '${libsPrefix()}' ${quoteShellArg(`${need.name}@${spec}`)} --registry '${registry}' --cache '${npmCacheDir()}'`;
+}
+
+export function isolatedInstallCommand(): string {
+  return `npm i --prefix '${toolchainDir()}' ${OPENCLI_NPM_PACKAGE}@${OPENCLI_PIN} --cache '${npmCacheDir()}'`;
+}