@jetcrab/pi-desk-sdk 0.0.0-stage → 1.0.1-dev.9001

package/dist/capabilities.d.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+export declare const CapabilityKeySchema: z.ZodString;
+export declare const CapabilityRuleSchema: z.ZodObject<{
+    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const CapabilityOptionSchema: z.ZodObject<{
+    value: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const CapabilityDeclarationSchema: z.ZodObject<{
+    label: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const CapabilityDeclarationsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    label: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const CapabilityModeKeySchema: z.ZodString;
+export declare const CapabilityModeSchema: z.ZodObject<{
+    name: z.ZodString;
+    tools: z.ZodOptional<z.ZodObject<{
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    skills: z.ZodOptional<z.ZodObject<{
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    plugins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>;
+export declare const CapabilityModesSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    tools: z.ZodOptional<z.ZodObject<{
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    skills: z.ZodOptional<z.ZodObject<{
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    plugins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>;
+export declare const CapabilityModeNamesSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+export declare const CapabilityCatalogSchema: z.ZodObject<{
+    tools: z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    skills: z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    plugins: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const SessionCapabilityRulesSchema: z.ZodObject<{
+    tools: z.ZodObject<{
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    skills: z.ZodObject<{
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    capabilities: z.ZodRecord<z.ZodString, z.ZodObject<{
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CapabilityMode = z.infer<typeof CapabilityModeSchema>;
+export type CapabilityModes = z.infer<typeof CapabilityModesSchema>;
+export type CapabilityModeNames = z.infer<typeof CapabilityModeNamesSchema>;
+export type CapabilityCatalog = z.infer<typeof CapabilityCatalogSchema>;
+export type CapabilityRule = z.infer<typeof CapabilityRuleSchema>;
+export type CapabilityOption = z.infer<typeof CapabilityOptionSchema>;
+export type CapabilityDeclaration = z.infer<typeof CapabilityDeclarationSchema>;
+export type CapabilityDeclarations = z.infer<typeof CapabilityDeclarationsSchema>;
+export type SessionCapabilityRules = z.infer<typeof SessionCapabilityRulesSchema>;
+/** Names are matched independently of discovery; a missing allowlist adds no restriction. */
+export declare function isCapabilityAllowed(rule: CapabilityRule | undefined, value: string): boolean;

package/dist/capabilities.js

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+export const CapabilityKeySchema = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
+const CapabilityPatternSchema = z.string().trim().min(1).max(256);
+export const CapabilityRuleSchema = z
+    .object({
+    allow: z.array(CapabilityPatternSchema).max(5000).optional(),
+    deny: z.array(CapabilityPatternSchema).max(5000).optional()
+})
+    .strict();
+export const CapabilityOptionSchema = z
+    .object({
+    value: z.string().trim().min(1).max(256),
+    label: z.string().trim().min(1).max(120).optional(),
+    description: z.string().trim().max(1000).optional()
+})
+    .strict();
+export const CapabilityDeclarationSchema = z
+    .object({
+    label: z.string().trim().min(1).max(120),
+    options: z.array(CapabilityOptionSchema).max(5000)
+})
+    .strict();
+export const CapabilityDeclarationsSchema = z.record(CapabilityKeySchema, CapabilityDeclarationSchema);
+export const CapabilityModeKeySchema = z.string().min(1).max(64);
+export const CapabilityModeSchema = z
+    .object({
+    name: z.string().trim().min(1).max(64),
+    tools: CapabilityRuleSchema.optional(),
+    skills: CapabilityRuleSchema.optional(),
+    plugins: z
+        .record(CapabilityKeySchema, z.record(CapabilityKeySchema, CapabilityRuleSchema))
+        .optional()
+})
+    .strict();
+export const CapabilityModesSchema = z
+    .record(CapabilityModeKeySchema, CapabilityModeSchema)
+    .refine((modes) => Object.keys(modes).length <= 100, '最多保存 100 个能力模式')
+    .refine((modes) => new Set(Object.values(modes).map((mode) => mode.name)).size === Object.keys(modes).length, '模式名称不能重复');
+export const CapabilityModeNamesSchema = z.record(CapabilityModeKeySchema, CapabilityModeSchema.shape.name);
+export const CapabilityCatalogSchema = z
+    .object({
+    tools: z.array(CapabilityOptionSchema),
+    skills: z.array(CapabilityOptionSchema),
+    plugins: z.record(CapabilityKeySchema, CapabilityDeclarationsSchema)
+})
+    .strict();
+export const SessionCapabilityRulesSchema = z
+    .object({
+    tools: CapabilityRuleSchema,
+    skills: CapabilityRuleSchema,
+    capabilities: z.record(CapabilityKeySchema, CapabilityRuleSchema)
+})
+    .strict();
+function matchesCapability(pattern, value) {
+    let patternIndex = 0;
+    let valueIndex = 0;
+    let starIndex = -1;
+    let retryIndex = 0;
+    while (valueIndex < value.length) {
+        if (pattern[patternIndex] === '*') {
+            starIndex = patternIndex++;
+            retryIndex = valueIndex;
+        }
+        else if (pattern[patternIndex] === value[valueIndex]) {
+            patternIndex += 1;
+            valueIndex += 1;
+        }
+        else if (starIndex >= 0) {
+            patternIndex = starIndex + 1;
+            valueIndex = ++retryIndex;
+        }
+        else {
+            return false;
+        }
+    }
+    while (pattern[patternIndex] === '*')
+        patternIndex += 1;
+    return patternIndex === pattern.length;
+}
+/** Names are matched independently of discovery; a missing allowlist adds no restriction. */
+export function isCapabilityAllowed(rule, value) {
+    return ((rule?.allow === undefined ||
+        rule.allow.some((pattern) => matchesCapability(pattern, value))) &&
+        !rule?.deny?.some((pattern) => matchesCapability(pattern, value)));
+}

package/dist/entry.d.ts

@@ -0,0 +1,137 @@
+import type { CapabilityDeclarations } from './capabilities.js';
+import type { HostSettings } from './settings.js';
+export type { HostRegion, HostSettings, HostSettingsSnapshot } from './settings.js';
+import { type PluginDisposer, type PluginJsonObject, type PluginJsonValue, type PluginNotificationLevel, type PluginSource, type PluginWorkSession } from './shared.ts';
+export type { BrowserBuiltinIconName, BrowserContributionIcon, PluginDisposer, PluginJsonObject, PluginJsonValue, PluginNotificationLevel, PluginSource, PluginWorkSession } from './shared.js';
+export interface GlobalPluginMethodContext {
+    readonly signal: AbortSignal;
+}
+export type PluginCapabilityLoader = (context: GlobalPluginMethodContext) => CapabilityDeclarations | Promise<CapabilityDeclarations>;
+export type GlobalPluginMethodHandler = (input: PluginJsonObject, context: GlobalPluginMethodContext) => Promise<PluginJsonObject>;
+export interface GlobalPluginFacade {
+    readonly name: string;
+    registerMethod(method: string, execute: GlobalPluginMethodHandler): () => void;
+}
+export interface GlobalPluginAPI {
+    bindPlugin(pluginName: string): GlobalPluginFacade;
+}
+export type GlobalPluginDisposer = PluginDisposer;
+export type GlobalPluginFactory = (api: GlobalPluginAPI) => void | GlobalPluginDisposer | Promise<void | GlobalPluginDisposer>;
+export type PluginPushTarget = {
+    scope: 'global';
+} | {
+    scope: 'session';
+    source: PluginSource;
+};
+export interface PluginPushMessage {
+    pluginName: string;
+    target: PluginPushTarget;
+    event: string;
+    data: PluginJsonObject;
+}
+export interface PiDeskWorkSessionCapability {
+    listWorkSessions(): Promise<readonly PluginWorkSession[]>;
+}
+export interface PiDeskPluginHost {
+    readonly settings: HostSettings;
+    readonly workSessions: PiDeskWorkSessionCapability;
+}
+export interface PluginNotificationEventInput {
+    name: string;
+    data: PluginJsonObject;
+}
+export interface PluginNotificationPublishInput {
+    level: PluginNotificationLevel;
+    title: string;
+    description?: string;
+    event?: PluginNotificationEventInput;
+}
+export interface PluginNotificationChanges {
+    level?: PluginNotificationLevel;
+    title?: string;
+    description?: string | null;
+}
+export interface PiDeskPluginNotifications {
+    publish(input: PluginNotificationPublishInput): string;
+    update(notificationId: string, changes: PluginNotificationChanges): void;
+    delete(notificationId: string): void;
+}
+export type PluginMessageProjectionStage = 'temporary' | 'update' | 'final' | 'durable';
+export interface PluginNativeImageMetadata {
+    mimeType: 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif';
+    width: number;
+    height: number;
+}
+export type PluginNativePiMessage = {
+    kind: 'user';
+    text: string;
+    images: readonly PluginNativeImageMetadata[];
+} | {
+    kind: 'assistant';
+    text: string;
+    thinking: string;
+    stopReason: string | null;
+} | {
+    kind: 'tool';
+    toolName: string;
+    toolCallId: string;
+    arguments: PluginJsonObject;
+    partialResult: PluginJsonValue;
+    result: PluginJsonValue;
+    isError: boolean;
+} | {
+    kind: 'bash';
+    command: string;
+    output: string;
+    exitCode: number | null;
+    cancelled: boolean;
+    truncated: boolean;
+} | {
+    kind: 'custom';
+    customType: string;
+    content: string;
+    details: PluginJsonValue;
+};
+export interface PluginMessageProjectionResult {
+    viewKey: string;
+    summary: PluginJsonObject;
+    detail: PluginJsonObject | null;
+}
+export interface PluginMessageDeclarationInput {
+    source: PluginSource;
+    stage: PluginMessageProjectionStage;
+    message: PluginNativePiMessage;
+    raw: unknown;
+    defaultProjection: PluginMessageProjectionResult;
+}
+export interface PluginMessageDeclaration {
+    priority: number;
+    match(input: PluginMessageDeclarationInput): boolean;
+    project(input: PluginMessageDeclarationInput): PluginMessageProjectionResult;
+}
+export interface PiDeskPluginFacade {
+    readonly name: string;
+    readonly host: PiDeskPluginHost;
+    readonly notifications: PiDeskPluginNotifications;
+    setState(state: PluginJsonObject | null): void;
+    registerMethod(method: string, execute: GlobalPluginMethodHandler): PluginDisposer;
+    registerBrowserEntry(relativePath: string): PluginDisposer;
+    declareCapabilities(load: PluginCapabilityLoader): PluginDisposer;
+    declareMessage(declarationName: string, declaration: PluginMessageDeclaration): PluginDisposer;
+    pushGlobal(event: string, data: PluginJsonObject): void;
+    pushSession(source: PluginSource, event: string, data: PluginJsonObject): void;
+}
+export interface PiDeskPluginReloadContext {
+    readonly signal: AbortSignal;
+}
+export interface PiDeskPluginLifecycle {
+    beforeReload?(context: PiDeskPluginReloadContext): void | Promise<void>;
+    dispose?: PluginDisposer;
+}
+export type PiDeskPluginSetupResult = void | PluginDisposer | PiDeskPluginLifecycle;
+export interface PiDeskPluginDefinition {
+    readonly name: string;
+    setup(plugin: PiDeskPluginFacade): PiDeskPluginSetupResult | Promise<PiDeskPluginSetupResult>;
+}
+export type PiDeskPluginFactory = PiDeskPluginDefinition;
+export declare function definePiDeskPlugin(definition: PiDeskPluginDefinition): PiDeskPluginDefinition;

package/dist/entry.js

@@ -0,0 +1,11 @@
+import { normalizePluginIdentifier } from "./shared.js";
+export function definePiDeskPlugin(definition) {
+    if (!definition || typeof definition !== 'object') {
+        throw new Error('Pi Desk Plugin definition must be an object');
+    }
+    const name = normalizePluginIdentifier(definition.name, 'pluginName');
+    if (typeof definition.setup !== 'function') {
+        throw new Error('Pi Desk Plugin setup must be a function');
+    }
+    return Object.freeze({ name, setup: definition.setup });
+}

package/dist/errors.d.ts

@@ -0,0 +1,8 @@
+export type PluginMethodErrorCode = 400 | 404 | 409;
+export declare class PluginMethodError extends Error {
+    readonly code: PluginMethodErrorCode;
+    constructor(code: PluginMethodErrorCode, message: string);
+}
+export declare function isPluginMethodError(value: unknown): value is Error & {
+    readonly code: PluginMethodErrorCode;
+};

package/dist/errors.js

@@ -0,0 +1,14 @@
+export class PluginMethodError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'PiDeskPluginMethodError';
+        this.code = code;
+    }
+}
+export function isPluginMethodError(value) {
+    if (!(value instanceof Error) || value.name !== 'PiDeskPluginMethodError')
+        return false;
+    const code = value.code;
+    return code === 400 || code === 404 || code === 409;
+}