@dsh-workbench/shared 0.1.0

package/dist/api/blocker-table.d.ts

@@ -0,0 +1,9 @@
+import type { Translate } from './dsh-client';
+import type { CapabilityPayload } from './workbench-contract';
+import type { ApiError } from './workbench-client';
+import type { ModuleBlocker } from './blocker';
+export declare function blockerOfError(error: ApiError | undefined, t: Translate, context?: {
+    path?: string | null;
+    platform?: string;
+}): ModuleBlocker;
+export declare function blockerOfCapability(capability: CapabilityPayload, t: Translate): ModuleBlocker | undefined;

package/dist/api/blocker-table.js

@@ -0,0 +1,130 @@
+import { shortenPath } from '../lib/ui.js';
+function retryAction(t) {
+    return { kind: 'retry', label: t('blocker.retry') };
+}
+function copyAction(t, text) {
+    return { kind: 'copy', label: t('blocker.copy'), text };
+}
+export function blockerOfError(error, t, context = {}) {
+    if (error === undefined) {
+        return {
+            id: 'unknown',
+            severity: 'block',
+            title: t('blocker.unknown.title'),
+            actions: [retryAction(t)],
+        };
+    }
+    switch (error.code) {
+        case 'auth-required': {
+            const path = shortenPath(context.path ?? '');
+            void path;
+            const actions = error.helpUrl === undefined
+                ? [retryAction(t)]
+                : [
+                    { kind: 'open-url', label: t('blocker.login.go'), url: error.helpUrl, inline: true },
+                    retryAction(t),
+                ];
+            return {
+                id: 'auth-required',
+                severity: 'block',
+                title: context.platform === undefined
+                    ? t('blocker.login.titleGeneric')
+                    : t('blocker.login.title', { platform: context.platform }),
+                hint: error.helpUrl === undefined ? t('blocker.login.manual') : t('blocker.login.hint'),
+                ...(error.detail === undefined ? {} : { detail: error.detail }),
+                actions,
+            };
+        }
+        case 'permission-denied': {
+            const actions = error.helpUrl === undefined
+                ? [retryAction(t)]
+                : [
+                    { kind: 'open-url', label: t('blocker.forbidden.open'), url: error.helpUrl },
+                    { kind: 'retry', label: t('blocker.retry') },
+                ];
+            return {
+                id: 'permission-denied',
+                severity: 'block',
+                title: context.platform === undefined
+                    ? t('blocker.forbidden.titleGeneric')
+                    : t('blocker.forbidden.title', { platform: context.platform }),
+                hint: t('blocker.forbidden.hint'),
+                ...(error.detail === undefined ? {} : { detail: error.detail }),
+                actions,
+            };
+        }
+        case 'cli-timeout':
+            return {
+                id: 'cli-timeout',
+                severity: 'notice',
+                title: error.message,
+                hint: error.hint ?? t('blocker.timeout.hint'),
+                ...(error.detail === undefined ? {} : { detail: error.detail }),
+                actions: [retryAction(t)],
+            };
+        case 'cli-exec-failed':
+            return {
+                id: 'cli-exec-failed',
+                severity: 'block',
+                title: error.message,
+                hint: error.hint ?? t('blocker.exec.hint'),
+                ...(error.detail === undefined ? {} : { detail: error.detail }),
+                actions: [retryAction(t)],
+            };
+        default:
+            return {
+                id: error.code,
+                severity: 'block',
+                title: error.message,
+                ...(error.hint === undefined ? {} : { hint: error.hint }),
+                ...(error.detail === undefined ? {} : { detail: error.detail }),
+                actions: [retryAction(t)],
+            };
+    }
+}
+export function blockerOfCapability(capability, t) {
+    if (capability.status === 'ok')
+        return undefined;
+    const fixAction = capability.fix === undefined
+        ? undefined
+        : {
+            kind: 'run-fix',
+            label: capability.fix === 'install' ? t('blocker.fix.install') : t('blocker.fix.update'),
+            unit: capability.unit,
+            fix: capability.fix,
+        };
+    const sourceUnknown = capability.fix === undefined && capability.install !== undefined && capability.install !== 'ready';
+    const install = [
+        ...(fixAction === undefined ? [] : [fixAction]),
+        ...(sourceUnknown ? [{ kind: 'open-market', label: t('blocker.market.open'), unit: capability.unit }] : []),
+        ...(capability.command === undefined || sourceUnknown ? [] : [copyAction(t, capability.command)]),
+    ];
+    if (capability.status === 'missing-plugin') {
+        return {
+            id: 'unit-missing-plugin',
+            severity: 'block',
+            title: t('env.unit.missingPlugin'),
+            hint: t('env.unit.hint'),
+            ...(capability.detail === undefined ? {} : { detail: capability.detail }),
+            actions: [...install, retryAction(t)],
+        };
+    }
+    if (capability.status === 'missing-commands') {
+        return {
+            id: 'unit-missing-commands',
+            severity: 'block',
+            title: t('env.unit.missingCommands'),
+            hint: t('env.unit.missingCommandsHint'),
+            ...(capability.detail === undefined ? {} : { detail: capability.detail }),
+            actions: [...install, retryAction(t)],
+        };
+    }
+    return {
+        id: 'unit-unchecked',
+        severity: 'notice',
+        title: t('env.unit.unchecked'),
+        hint: t('env.unit.uncheckedHint'),
+        ...(capability.detail === undefined ? {} : { detail: capability.detail }),
+        actions: [retryAction(t)],
+    };
+}

package/dist/api/blocker.d.ts

@@ -0,0 +1,30 @@
+export type BlockerAction = {
+    readonly kind: 'open-url';
+    readonly label: string;
+    readonly url: string;
+    readonly inline?: boolean;
+} | {
+    readonly kind: 'copy';
+    readonly label: string;
+    readonly text: string;
+} | {
+    readonly kind: 'retry';
+    readonly label: string;
+} | {
+    readonly kind: 'run-fix';
+    readonly label: string;
+    readonly unit: string;
+    readonly fix: 'install' | 'update';
+} | {
+    readonly kind: 'open-market';
+    readonly label: string;
+    readonly unit: string;
+};
+export interface ModuleBlocker {
+    readonly id: string;
+    readonly severity: 'block' | 'notice';
+    readonly title: string;
+    readonly hint?: string;
+    readonly detail?: string;
+    readonly actions: readonly BlockerAction[];
+}

package/dist/api/blocker.js

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

package/dist/api/context-ref.d.ts

@@ -0,0 +1,10 @@
+export declare const CONTEXT_MARKER_NAME = "\u5DE5\u4F5C\u53F0";
+export interface ContextRef {
+    readonly kind: string;
+    readonly parts: readonly string[];
+}
+export declare function encodeRef(ref: ContextRef): string;
+export declare function decodeRef(text: string): ContextRef | undefined;
+export declare function markerBody(encoded: string): string;
+export declare function buildMarker(ref: ContextRef): string;
+export declare function parseMarkers(text: string): ContextRef[];

package/dist/api/context-ref.js

@@ -0,0 +1,40 @@
+export const CONTEXT_MARKER_NAME = '工作台';
+const MARKER = new RegExp(`@${CONTEXT_MARKER_NAME}:([a-z][a-z0-9-]*:[A-Za-z0-9._~%#/-]+)`, 'g');
+const TRAILING_PUNCTUATION = /[.,;:!?]+$/;
+export function encodeRef(ref) {
+    return `${ref.kind}:${ref.parts.join('/')}`;
+}
+export function decodeRef(text) {
+    const at = text.indexOf(':');
+    if (at <= 0 || at === text.length - 1)
+        return undefined;
+    const kind = text.slice(0, at);
+    if (!/^[a-z][a-z0-9-]*$/.test(kind))
+        return undefined;
+    const parts = text.slice(at + 1).split('/').filter((part) => part !== '');
+    if (parts.length === 0)
+        return undefined;
+    return { kind, parts };
+}
+export function markerBody(encoded) {
+    return `${CONTEXT_MARKER_NAME}:${encoded}`;
+}
+export function buildMarker(ref) {
+    return `@${markerBody(encodeRef(ref))}`;
+}
+export function parseMarkers(text) {
+    const seen = new Set();
+    const refs = [];
+    for (const match of String(text ?? '').matchAll(MARKER)) {
+        const raw = match[1].replace(TRAILING_PUNCTUATION, '');
+        const ref = decodeRef(raw);
+        if (ref === undefined)
+            continue;
+        const key = encodeRef(ref);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        refs.push(ref);
+    }
+    return refs;
+}

package/dist/api/dsh-client.d.ts

@@ -0,0 +1,170 @@
+import type { ReactNode } from 'react';
+export interface WorkspaceView {
+    readonly workspaceId: string;
+    readonly path: string;
+    readonly title: string;
+    readonly sessionIds: readonly string[];
+    readonly createdAt: number;
+    readonly updatedAt: number;
+}
+export interface WorkspaceSnapshot {
+    readonly items: readonly WorkspaceView[];
+    readonly archivedSessionIds: readonly string[];
+    readonly pinnedSessionIds: readonly string[];
+}
+export interface SessionSummary {
+    readonly id: string;
+    readonly displayTitle: string;
+    readonly blank: boolean;
+    readonly running: boolean;
+    readonly updatedAt: number;
+    readonly origin?: string;
+    readonly retainedBy: Readonly<Partial<Record<string, number>>>;
+}
+export interface SubagentCatalogEntry {
+    readonly id: string;
+}
+export interface SessionsSnapshot {
+    readonly byId: Readonly<Record<string, SessionSummary>>;
+    readonly projectionsBySession: Readonly<Record<string, {
+        values?: {
+            subagentCatalog?: readonly SubagentCatalogEntry[];
+        };
+    } | undefined>>;
+}
+export interface SessionStatus {
+    readonly running?: boolean;
+    readonly completionUnread?: boolean;
+    readonly pendingInteraction?: {
+        readonly kind?: string;
+    };
+}
+export type SessionStatusSnapshot = ReadonlyMap<string, SessionStatus>;
+export interface PanelInfo {
+    readonly activePanelId: string | null;
+}
+export interface PanelEntry {
+    readonly id: string;
+    readonly order: number;
+    readonly label: string | (() => string);
+}
+export type SnapshotSelectorHook<T> = <R>(selector: (state: T) => R) => R;
+export type RenderSlot = (key: string, owner?: Record<string, unknown>, options?: {
+    fallback?: ReactNode;
+    hookContext?: unknown;
+    only?: string;
+}) => ReactNode;
+export type Translate = (key: string, params?: Record<string, unknown>) => string;
+export interface SlotRegisterOptions {
+    name: string;
+    priority?: number;
+    key?: string;
+    id?: string;
+    order?: number;
+    locale?: string;
+    label?: string | (() => string);
+    children?: Record<string, unknown>;
+    inject?: (scope?: unknown) => Record<string, unknown>;
+}
+export interface DshSlots {
+    inject(name: string, callback: () => void | (() => void) | Iterable<() => void>): () => void;
+    register(options: SlotRegisterOptions, component: unknown): () => void;
+    entriesOfSlot(name: string): Array<{
+        options: SlotRegisterOptions;
+    }>;
+    subscribe(name: string, callback: () => void): () => void;
+    specDynamic?(name: string): unknown;
+    onMutate?(callback: (name: string) => void): () => void;
+}
+export interface DshLocale {
+    register(namespace: string, dictionaries: Record<string, Record<string, string>>): () => void;
+    bind(namespace: string): Translate;
+}
+export interface DshLayout {
+    selectPanel(panelId: string | null): void;
+    toggleSidebar(): void;
+    openRightbar(track: boolean, fullscreen: boolean): void;
+    closeRightbar(): void;
+    readonly panels?: DshLayoutPanels;
+}
+export interface DshLayoutPanels {
+    setRightbar?(px: number): void;
+}
+export interface DshShortcutCatalog {
+    readonly catalog: unknown;
+}
+export interface DshUiWorkspace {
+    openWorkspace(workspaceId: string): Promise<unknown>;
+    openSession(sessionId: string): void;
+    startSession(workspaceId: string): void;
+    pickDirectory(): Promise<string | null>;
+}
+export interface DshWorkspaces {
+    create(request: {
+        path: string;
+    }): Promise<{
+        workspaceId?: string;
+    } | undefined>;
+}
+export interface DshReferenceInsert {
+    readonly source: string;
+    readonly ref: string;
+    readonly label: string;
+    readonly appearance?: 'session' | 'file' | 'folder';
+    readonly clipboardText: string;
+}
+export interface DshTokenSpan {
+    readonly start: number;
+    readonly end: number;
+    readonly draftRev: number;
+}
+export interface DshSessionInput {
+    caretSpan?: () => {
+        start: number;
+        end: number;
+    };
+    readonly state: {
+        getSnapshot(): {
+            draftRev: number;
+        } | undefined;
+    };
+    insertReference(ref: DshReferenceInsert, span: DshTokenSpan): boolean;
+    notify(level: 'info' | 'error', text: string): void;
+}
+export interface DshInputTriggers {
+    registerSource(source: {
+        readonly trigger: '@';
+        readonly name: string;
+        readonly order?: number;
+        candidates: () => Promise<readonly unknown[]>;
+        onPick: () => undefined;
+        lexicon?: (session: unknown) => readonly string[] | undefined;
+        subscribeLexicon?: (session: unknown, listener: () => void) => () => void;
+        readonly codec?: {
+            clipboardText(ref: string): string;
+            serialize(ref: string, signal?: AbortSignal): Promise<string>;
+        };
+    }): () => void;
+}
+export interface DshConversationService {
+    readonly input: {
+        for(actx: unknown): DshSessionInput;
+    };
+}
+export interface DshSessionsService {
+    readonly list: {
+        getSnapshot(): SessionsSnapshot;
+    };
+    scope(sessionId: string): unknown | undefined;
+}
+export interface DshClientContext {
+    get<T = unknown>(name: string): T | undefined;
+    provide(name: string, value: unknown): void;
+    effect(effect: () => void | (() => void), label?: string): () => void;
+    readonly slots: DshSlots;
+    readonly locale: DshLocale;
+    readonly layout: DshLayout;
+    readonly uiWorkspace: DshUiWorkspace;
+    readonly workspaces: DshWorkspaces;
+    readonly shortcuts: DshShortcutCatalog;
+}

package/dist/api/dsh-client.js

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

package/dist/api/dsh.d.ts

@@ -0,0 +1,153 @@
+export interface DshLogger {
+    info?(message: string): void;
+    warn?(message: string): void;
+}
+export interface DshRequest {
+    readonly method?: string;
+    readonly url?: string;
+    [Symbol.asyncIterator]?(): AsyncIterator<Uint8Array>;
+}
+export interface DshResponse {
+    statusCode: number;
+    setHeader(name: string, value: string): void;
+    end(body?: string): void;
+    writeHead?(status: number, headers: Record<string, string>): void;
+    write?(chunk: string): void;
+    on?(event: 'close', listener: () => void): void;
+}
+export interface DshWebRoute {
+    readonly kind: 'prefix' | 'exact';
+    readonly path: string;
+    readonly handler: (req: DshRequest, res: DshResponse) => void | Promise<void>;
+}
+export interface DshProfileContext {
+    readonly dir?: string;
+}
+export interface DshToolSchema {
+    readonly name: string;
+    readonly [key: string]: unknown;
+}
+export interface DshPromptAssembly {
+    readonly tools?: readonly DshToolSchema[] | undefined;
+    readonly [key: string]: unknown;
+}
+export interface DshAssemblyContext {
+    readonly agent?: unknown;
+    readonly scope?: unknown;
+    readonly [key: string]: unknown;
+}
+export interface DshHostContext {
+    on?: {
+        (event: 'system-prompt/assemble', listener: (assembly: DshPromptAssembly, context: DshAssemblyContext, next: () => Promise<DshPromptAssembly>) => Promise<DshPromptAssembly>): (() => void) | undefined;
+    } & {
+        (event: 'tools/pre-execute', listener: (exec: {
+            name?: string;
+            arguments?: unknown;
+            readonly agent?: DshToolRunContext['agent'];
+        }, next: () => Promise<{
+            kind: 'allow';
+        } | {
+            kind: 'deny';
+            reason: string;
+        } | {
+            kind: 'cancel';
+        } | {
+            kind: 'ask';
+            reason?: string;
+            displayReason?: Record<string, string>;
+        }>) => Promise<{
+            kind: 'allow';
+        } | {
+            kind: 'deny';
+            reason: string;
+        } | {
+            kind: 'cancel';
+        } | {
+            kind: 'ask';
+            reason?: string;
+            displayReason?: Record<string, string>;
+        }>): (() => void) | undefined;
+    } & {
+        (event: 'tools/post-execute', listener: (exec: {
+            name?: string;
+            arguments?: unknown;
+        }, result: unknown, next: () => unknown) => unknown): (() => void) | undefined;
+    } & {
+        (event: 'agent/created', listener: (payload: {
+            agent?: unknown;
+        }) => void): (() => void) | undefined;
+    } & {
+        (event: 'agent/pre-step', listener: (payload: {
+            agent?: unknown;
+            messages?: readonly unknown[];
+        }, next: () => Promise<{
+            kind: string;
+            messages?: readonly unknown[];
+        }>) => Promise<{
+            kind: string;
+            messages?: readonly unknown[];
+        }>): (() => void) | undefined;
+    };
+    get<T = unknown>(name: string): T | undefined;
+    provide(name: string, value: unknown): () => void;
+    effect(effect: () => void | (() => void), label?: string): () => void;
+    readonly logger?: DshLogger;
+    readonly webServer: {
+        register(route: DshWebRoute): () => void;
+    };
+}
+export interface DshShellExecution {
+    result(): Promise<{
+        exitCode: number | null;
+        timedOut: boolean;
+        aborted: boolean;
+        stdout: {
+            text: string;
+            truncated: boolean;
+        };
+        stderr: {
+            text: string;
+            truncated: boolean;
+        };
+    }>;
+}
+export interface DshShell {
+    resolve(request: {
+        command: string;
+        workdir?: string;
+        timeoutMs?: number;
+        onExpiry?: 'kill' | 'none';
+        stdoutMaxBytes?: number;
+        signal?: AbortSignal;
+    }): unknown;
+    execute(spec: unknown): Promise<DshShellExecution>;
+}
+export interface DshWorkspaceRegistry {
+    get(id: string): {
+        id: string;
+        path?: string;
+        title?: string;
+    } | undefined;
+}
+export interface DshToolDefinition {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    output: {
+        schema: Record<string, unknown>;
+        render(args: unknown, value: unknown): Array<Record<string, unknown>>;
+    };
+    execute(args: any, exec: DshToolRunContext): Promise<unknown>;
+}
+export interface DshToolRunContext {
+    readonly agent?: {
+        readonly session?: {
+            readonly header?: {
+                readonly cwd?: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}
+export interface DshToolRegistry {
+    register(definition: DshToolDefinition): () => void;
+}

package/dist/api/dsh.js

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

package/dist/api/facts.d.ts

@@ -0,0 +1,27 @@
+export interface FactFrame {
+    readonly epoch?: string;
+    readonly rev: number;
+    readonly facts: readonly string[];
+}
+export declare const FACT_SCOPE_SUFFIX = "*";
+export declare function unitFactScope(unit: string): string;
+export declare function isFactScope(name: string): boolean;
+export declare function scopePrefixOf(name: string): string;
+export interface FactTransport {
+    start(handlers: {
+        readonly onFrame: (frame: FactFrame) => void;
+        readonly cursor: () => number;
+    }): () => void;
+}
+export interface FactChannel {
+    subscribe(fact: string, listener: () => void): () => void;
+    revisionOf(fact: string): number;
+    refresh(fact?: string): void;
+    applyFrame(frame: FactFrame): void;
+    subscriberCount(): number;
+}
+export declare function createFactChannel(options: {
+    readonly transport: FactTransport;
+}): FactChannel;
+export declare function parseFactFrame(data: unknown): FactFrame | null;
+export declare function factOfRoute(route: string): string;