@liyuera/dsh-dev-dock 0.0.0-stage → 1.0.3

package/lib/types/client/pages/ProjectListPage.d.ts

@@ -0,0 +1,34 @@
+/**
+ * devDock projects page: the registered project list with per-project
+ * actions (open in terminal / IDE via the agent, remove from registry).
+ */
+import type { InjectFace, PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { DevDockActions, DevDockData } from '../api.ts';
+import { NS } from '../locales.ts';
+import type { DevDockPage } from '../stores.ts';
+/** Registration-side inject face (same shape as the drawer's). */
+export interface ProjectListInjected {
+    hooks: {
+        /** Settings snapshot bound by the renderer as useDevDockData. */
+        devDockData: {
+            getSnapshot(): DevDockData;
+            subscribe(fn: () => void): () => void;
+        };
+    };
+    /** Data mutation actions. */
+    actions: DevDockActions;
+    /** Prompt the current session to run a dev-dock action tool. */
+    promptAgent: (text: string) => Promise<boolean>;
+}
+/** Full component props. */
+export type ProjectListPageProps = PropsLocale<typeof NS> & InjectFace<ProjectListInjected> & {
+    /** Navigate to another drawer page. */
+    onNavigate: (page: DevDockPage) => void;
+};
+/**
+ * Render the projects page.
+ * @param props - data hook, actions, navigator, translator.
+ * @returns the project list.
+ */
+export declare function ProjectListPage({ useDevDockData, actions, promptAgent, onNavigate, t }: ProjectListPageProps): import("react").JSX.Element;
+//# sourceMappingURL=ProjectListPage.d.ts.map

package/lib/types/client/pages/QuickStartPage.d.ts

@@ -0,0 +1,26 @@
+import type { InjectFace, PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { DevDockActions, DevDockData } from '../api.ts';
+import { NS } from '../locales.ts';
+/** Registration-side inject face (same shape as the drawer's). */
+export interface QuickStartInjected {
+    hooks: {
+        /** Settings snapshot bound by the renderer as useDevDockData. */
+        devDockData: {
+            getSnapshot(): DevDockData;
+            subscribe(fn: () => void): () => void;
+        };
+    };
+    /** Data mutation actions. */
+    actions: DevDockActions;
+    /** Prompt the current session to run a dev-dock action tool. */
+    promptAgent: (text: string) => Promise<boolean>;
+}
+/** Full component props. */
+export type QuickStartPageProps = PropsLocale<typeof NS> & InjectFace<QuickStartInjected>;
+/**
+ * Render the quick-start page.
+ * @param props - view store, data hook, actions, translator.
+ * @returns the quick-start editor.
+ */
+export declare function QuickStartPage({ useDevDockData, actions, promptAgent, t }: QuickStartPageProps): import("react").JSX.Element;
+//# sourceMappingURL=QuickStartPage.d.ts.map

package/lib/types/client/probe.d.ts

@@ -0,0 +1,3 @@
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+export declare function probe(ctx: ClientContext): void;
+//# sourceMappingURL=probe.d.ts.map

package/lib/types/client/stores.d.ts

@@ -0,0 +1,22 @@
+/**
+ * devDock panel viewing store: the start-work dialog open state. Shared by
+ * the sidebar footer button and entry row so the dialog opens from either
+ * and survives entry/overlay remounts.
+ * @module @liyuera/dsh-dev-dock/client/stores
+ */
+import { type EngineStoreHandle } from '@deepseek-ai/dsh-client-store';
+/** Panel viewing state. */
+export type DevDockViewState = {
+    /** Whether the start-work dialog is open. */
+    open: boolean;
+};
+/** Annotation twin of the actions literal (see defineStore contract). */
+export type DevDockViewActions = {
+    setOpen: (draft: DevDockViewState, open: boolean) => void;
+};
+/**
+ * Create the devDock viewing store.
+ * @returns the store handle (spec + type + identity + factory in one).
+ */
+export declare function createDevDockStore(): EngineStoreHandle<DevDockViewState, DevDockViewActions>;
+//# sourceMappingURL=stores.d.ts.map

package/lib/types/domain.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The whole document rides the domain's global slot: devDock has exactly one
+ * settings document, and a `single` layout stores it as one readable file
+ * under `$DSH_HOME/storages`. A stored document that fails the schema makes
+ * `open` reject — this is authoritative user preference, not disposable cache,
+ * so it must fail loud rather than silently reset.
+ */
+export declare const devDockDomain: {
+    name: string;
+    version: number;
+    global: {
+        schema: import("zod").ZodType<import("./schema.ts").DevDockSettings, unknown, import("zod/v4/core").$ZodTypeInternals<import("./schema.ts").DevDockSettings, unknown>>;
+        initial: import("./schema.ts").DevDockSettings;
+    };
+    tables: {};
+};
+//# sourceMappingURL=domain.d.ts.map

package/lib/types/editors.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Editor detection service: merges live auto-detection with user-configured
+ * paths from settings. The detection routines themselves live in the
+ * platform directory.
+ * @module @liyuera/dsh-dev-dock/editors
+ */
+import type { EditorRecord } from './schema.ts';
+import type { PlatformFacts } from './platform/runner.ts';
+/** Known editor names across platforms (union for stable UI display). */
+export declare const KNOWN_EDITORS: readonly ["WebStorm", "VS Code", "IntelliJ IDEA", "Cursor", "Sublime Text", "HBuilderX"];
+/** Preferable non-uni-app editors, in preference order. */
+export declare const PREFERRED_EDITORS: readonly ["WebStorm", "VS Code", "Cursor", "IntelliJ IDEA", "Sublime Text"];
+/**
+ * Run platform editor detection.
+ * @param facts - platform facts.
+ * @returns detected paths keyed by editor name.
+ */
+export declare function detectEditors(facts: PlatformFacts): Promise<Record<string, string>>;
+/**
+ * Merge detected paths with manual configuration: manual overrides detection
+ * for the same editor; detected paths refresh the cache.
+ * @param detected - live detection result.
+ * @param stored - editors from settings.
+ * @returns merged editor records; empty entries are dropped.
+ */
+export declare function mergeEditors(detected: Record<string, string>, stored: readonly EditorRecord[]): EditorRecord[];
+//# sourceMappingURL=editors.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * devDock plugin v2, node half. Projects are dsh workspaces; this half
+ * registers the `dev-dock` settings namespace and the desktop-action HTTP
+ * route (`POST /dev-dock/action`) that the browser half calls for editor
+ * detection and the desktop actions (open editor / system terminal /
+ * start-work). Deterministic execution: no agent, no tools, no approval
+ * prompt — the button click is the user's authorization. The only guard is
+ * the sandbox mode: `read-only` denies desktop side effects.
+ *
+ * Transport note: static client bundles have no package-private RPC channel
+ * (host.call is a dynamic-plugin builtin), so the browser half reaches the
+ * host through a same-origin route on the loopback web server.
+ * @module @liyuera/dsh-dev-dock
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Plugin identity. */
+export declare const name = "dev-dock";
+/**
+ * Services required by the host half. `webServer` and `storageDomain` mount
+ * later in the tree than this row, so they must be declared here: reading them
+ * through `ctx.get` in `apply` would find an empty context and silently leave
+ * every route and the document unregistered.
+ */
+export declare const inject: string[];
+/**
+ * Register the document domain, the state route, and the desktop-action routes.
+ * @param ctx - Cordis context carrying the web server, the storage facility, the
+ * workspace registry, and the sandbox policy.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@liyuera/dsh-dev-dock`.
+ * @module @liyuera/dsh-dev-dock/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "dev-dock-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/platform/editors-darwin.d.ts

@@ -0,0 +1,25 @@
+/**
+ * macOS editor detection: Spotlight (mdfind) with a filesystem fallback
+ * under /Applications and ~/Applications.
+ * @module @liyuera/dsh-dev-dock/platform/editors-darwin
+ */
+import type { PlatformFacts } from './runner.ts';
+/** Known macOS editor app bundles. */
+export declare const DARWIN_EDITOR_APPS: ReadonlyArray<{
+    name: string;
+    app: string;
+}>;
+/**
+ * Resolve one app bundle path via Spotlight, then the filesystem fallback.
+ * @param facts - platform facts with an injectable runner.
+ * @param app - app bundle name (e.g. "WebStorm.app").
+ * @returns the app path or undefined when not installed.
+ */
+export declare function detectDarwinApp(facts: PlatformFacts, app: string): Promise<string | undefined>;
+/**
+ * Detect every known macOS editor.
+ * @param facts - platform facts.
+ * @returns detected editor paths keyed by editor name.
+ */
+export declare function detectDarwinEditors(facts: PlatformFacts): Promise<Record<string, string>>;
+//# sourceMappingURL=editors-darwin.d.ts.map

package/lib/types/platform/editors-win32.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Windows editor detection: registry App Paths (HKCU then HKLM) with a
+ * `where` PATH fallback.
+ * @module @liyuera/dsh-dev-dock/platform/editors-win32
+ */
+import type { PlatformFacts } from './runner.ts';
+/** Known Windows editor executables. */
+export declare const WIN32_EDITOR_EXES: ReadonlyArray<{
+    name: string;
+    exe: string;
+}>;
+/**
+ * Locate one editor executable via registry then `where`.
+ * @param facts - platform facts.
+ * @param exe - executable name.
+ * @returns the executable path or undefined when not installed.
+ */
+export declare function detectWin32Editor(facts: PlatformFacts, exe: string): Promise<string | undefined>;
+/**
+ * Detect every known Windows editor.
+ * @param facts - platform facts.
+ * @returns detected editor paths keyed by editor name.
+ */
+export declare function detectWin32Editors(facts: PlatformFacts): Promise<Record<string, string>>;
+//# sourceMappingURL=editors-win32.d.ts.map

package/lib/types/platform/open-ide.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Cross-platform "open project in IDE" actions. Every command goes through
+ * the no-shell runner with an argv array; no shell string is ever built.
+ * @module @liyuera/dsh-dev-dock/platform/open-ide
+ */
+import type { PlatformFacts } from './runner.ts';
+/** IDE display name → macOS app bundle name. */
+export declare const DARWIN_APP_NAMES: Record<string, string>;
+/**
+ * Open one project with an IDE.
+ * @param facts - platform facts with an injectable runner.
+ * @param projectPath - absolute project path.
+ * @param editorName - canonical editor name.
+ * @param editorPath - resolved editor executable/app path (detected or manual).
+ * @returns ok, or an error message when the open failed.
+ */
+export declare function openProjectInIde(facts: PlatformFacts, projectPath: string, editorName: string, editorPath: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+//# sourceMappingURL=open-ide.d.ts.map

package/lib/types/platform/open-terminal.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Cross-platform "open a system terminal window" actions. macOS drives
+ * Terminal.app through osascript (iTerm fallback when the config asks for it
+ * or Terminal fails); Windows prefers Windows Terminal and falls back to a
+ * plain cmd window. Every command goes through the no-shell runner.
+ * @module @liyuera/dsh-dev-dock/platform/open-terminal
+ */
+import type { PlatformFacts } from './runner.ts';
+/** Build the shell command executed inside the terminal window. */
+export declare function terminalCommand(projectPath: string, command?: string): string;
+/**
+ * Open a system terminal window at a project directory.
+ * @param facts - platform facts.
+ * @param projectPath - absolute project path.
+ * @param command - optional command to run after cd.
+ * @param preferIterm - macOS: prefer iTerm over Terminal.app.
+ * @returns ok, or an error message.
+ */
+export declare function openProjectTerminal(facts: PlatformFacts, projectPath: string, command?: string, preferIterm?: boolean): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+//# sourceMappingURL=open-terminal.d.ts.map

package/lib/types/platform/runner.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Host command runner facade: wraps `runNativeCommand` behind an injectable
+ * platform seam so platform logic is deterministically testable.
+ * @module @liyuera/dsh-dev-dock/platform/runner
+ */
+import { type NativeCommandRunner } from '@deepseek-ai/dsh-native-command';
+/** Command boundary signature mirrored from native-command. */
+export type CommandRunner = NativeCommandRunner;
+/** Default runner: no-shell execFile with utf8 capture. */
+export declare const defaultRunner: CommandRunner;
+/** Injectable platform facts for deterministic adapter tests. */
+export interface PlatformFacts {
+    /** Node platform string. */
+    platform: NodeJS.Platform;
+    /** Executable runner (defaults to the real one). */
+    run: CommandRunner;
+    /** HOME directory used by macOS app detection. */
+    home: string;
+}
+/** Build the live platform facts. */
+export declare function liveFacts(): PlatformFacts;
+//# sourceMappingURL=runner.d.ts.map

package/lib/types/schema.d.ts

@@ -0,0 +1,52 @@
+/**
+ * devDock document v2: per-workspace IDE preferences, editor manual paths,
+ * terminal preference, and the start-work selection memory. Projects are dsh
+ * workspaces, so no separate project registry exists. Persisted through the
+ * storage capability (`$DSH_HOME/storages/dev_dock.json`, domain `dev_dock`).
+ * @module @liyuera/dsh-dev-dock/schema
+ */
+import { z } from 'zod';
+/** Workspace id (dsh workspace registry id) one IDE preference is keyed by. */
+export type WorkspacePrefKey = string;
+/** One known editor: auto-detected path and/or user-configured path. */
+export interface EditorRecord {
+    /** Canonical editor name (WebStorm, VS Code, IntelliJ IDEA, Cursor, Sublime Text, HBuilderX). */
+    name: string;
+    /** Auto-detected executable/app path (empty when not installed). */
+    detectedPath?: string | undefined;
+    /** User-configured executable/app path (HBuilderX relies on this). */
+    manualPath?: string | undefined;
+}
+/** Whole devDock document. */
+export interface DevDockSettings {
+    /** Per-workspace IDE preference (falls back to auto-detection defaults). */
+    workspacePrefs: Array<{
+        workspaceId: WorkspacePrefKey;
+        editor: string;
+    }>;
+    /** Editor detection cache plus user-configured paths. */
+    editors: EditorRecord[];
+    /** macOS terminal preference; 'default' uses Terminal.app, 'iterm' iTerm. */
+    terminalApp: 'default' | 'iterm';
+    /** Workspace ids of the last start-work selection (dialog prefill). */
+    startWork: string[];
+}
+/**
+ * Storage domain holding the document. `UNIT_NAME_RE` forbids hyphens, so the
+ * domain name is underscored while the HTTP paths keep the hyphenated form.
+ */
+export declare const DEV_DOCK_DOMAIN = "dev_dock";
+/** The four fields the browser half may write, one at a time. */
+export declare const DEV_DOCK_FIELDS: readonly ["workspacePrefs", "editors", "terminalApp", "startWork"];
+/** One field name the browser half may write. */
+export type DevDockField = (typeof DEV_DOCK_FIELDS)[number];
+/**
+ * Document schema. Doubles as the storage domain's global schema (validated at
+ * the durable read boundary) and as the write guard for the browser route: a
+ * patch that would store a document this schema rejects is refused before it
+ * reaches the medium.
+ */
+export declare const DevDockDocumentSchema: z.ZodType<DevDockSettings>;
+/** Document served before the first write. */
+export declare const EMPTY_DEV_DOCK_SETTINGS: DevDockSettings;
+//# sourceMappingURL=schema.d.ts.map

package/lib/types/tools/actions.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Desktop action tools: open a project in an IDE, open a system terminal at
+ * a project (optionally running one script), and run a quick-start plan.
+ * All three are user-visible desktop side effects and follow the approval
+ * pipeline: `never` policy executes directly, `ask` goes through
+ * `ctx.approval.request` with one consolidated question per tool call.
+ * @module @liyuera/dsh-dev-dock/tools/actions
+ */
+import type { ToolRunContext } from '@deepseek-ai/dsh-tools';
+import type { ApprovalService } from '@deepseek-ai/dsh-user-approval';
+import type { DevDockScope } from './project.ts';
+import type { PlatformFacts } from '../platform/runner.ts';
+/**
+ * Decide whether one desktop action may run: the session's effective
+ * approval policy, asking through the approval service when the policy is
+ * `ask`. The `never` policy never asks — full access executes directly.
+ * @param approval - the approval service.
+ * @param exec - the live tool execution carrying the agent.
+ * @param toolName - tool identity for the audit pair.
+ * @param reason - user-facing explanation of the action.
+ * @returns true when the action is allowed.
+ */
+export declare function requireApproval(approval: ApprovalService, exec: ToolRunContext, toolName: string, reason: string): Promise<{
+    allowed: true;
+} | {
+    allowed: false;
+    error: string;
+}>;
+/** Tool: open one project in an IDE. */
+export declare function openIdeTool(scope: DevDockScope, facts: PlatformFacts, approval: ApprovalService): import("@deepseek-ai/dsh-tools").ToolDefinition;
+/** Tool: open a system terminal at a project, optionally running one script. */
+export declare function openTerminalTool(scope: DevDockScope, facts: PlatformFacts, approval: ApprovalService): import("@deepseek-ai/dsh-tools").ToolDefinition;
+/** Tool: run one quick-start plan (batch open IDEs + start scripts). */
+export declare function quickStartTool(scope: DevDockScope, facts: PlatformFacts, approval: ApprovalService): import("@deepseek-ai/dsh-tools").ToolDefinition;
+//# sourceMappingURL=actions.d.ts.map

package/lib/types/tools/editors.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Editor detection tool: merges live auto-detection with user-configured
+ * paths from settings, and persists detected paths back for the UI.
+ * @module @liyuera/dsh-dev-dock/tools/editors
+ */
+import type { DevDockScope } from './project.ts';
+import type { EditorRecord } from '../schema.ts';
+import type { PlatformFacts } from '../platform/runner.ts';
+/** Known editor names across platforms (union for stable UI display). */
+export declare const KNOWN_EDITORS: readonly ["WebStorm", "VS Code", "IntelliJ IDEA", "Cursor", "Sublime Text", "HBuilderX"];
+/**
+ * Run platform editor detection.
+ * @param facts - platform facts.
+ * @returns detected paths keyed by editor name.
+ */
+export declare function detectEditors(facts: PlatformFacts): Promise<Record<string, string>>;
+/**
+ * Merge detected paths with manual configuration: detected wins unless a
+ * manual path exists (manual overrides detection for the same editor).
+ * @param detected - live detection result.
+ * @param stored - editors from settings.
+ * @returns merged editor records, persisted order kept, new names appended.
+ */
+export declare function mergeEditors(detected: Record<string, string>, stored: readonly EditorRecord[]): EditorRecord[];
+/** Tool: detect installed editors and merge user configuration. */
+export declare function listEditorsTool(scope: DevDockScope, facts: PlatformFacts): import("@deepseek-ai/dsh-tools").ToolDefinition;
+//# sourceMappingURL=editors.d.ts.map

package/lib/types/tools/project.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Project registry tools: save (upsert), list, remove. All mutations go
+ * through the plugin's settings namespace scope.
+ * @module @liyuera/dsh-dev-dock/tools/project
+ */
+import type { SettingsScope } from '@deepseek-ai/dsh-settings';
+import type { DevDockSettings, ProjectId, ProjectRecord } from '../schema.ts';
+/** Scope facade the tools read and mutate. */
+export interface DevDockScope {
+    /** Read the current settings document. */
+    get(): DevDockSettings;
+    /** Merge a partial patch into the document. */
+    update(patch: Partial<DevDockSettings>): void;
+}
+/** Wrap a live settings scope behind the tool facade. */
+export declare function scopeOf(scope: SettingsScope<DevDockSettings>): DevDockScope;
+/**
+ * Mint the next project id (max numeric id + 1, or "1").
+ * @param projects - current project list.
+ * @returns the next id.
+ */
+export declare function nextProjectId(projects: readonly ProjectRecord[]): ProjectId;
+/**
+ * Upsert one project: same path keeps its id and createdAt (update overwrite).
+ * @param current - current document.
+ * @param project - candidate project record (id may be empty on insert).
+ * @returns the new document and the stored record.
+ */
+export declare function upsertProject(current: DevDockSettings, project: Omit<ProjectRecord, 'id' | 'createdAt'> & {
+    id?: ProjectId;
+}): {
+    next: DevDockSettings;
+    stored: ProjectRecord;
+};
+/**
+ * Remove one project and cascade-clean its quick-start references.
+ * @param current - current document.
+ * @param projectId - project id to remove.
+ * @returns the new document; false when the id did not exist.
+ */
+export declare function removeProject(current: DevDockSettings, projectId: ProjectId): {
+    next: DevDockSettings;
+} | null;
+/** Tool: save one analyzed project (insert or update overwrite). */
+export declare function saveProjectTool(scope: DevDockScope): import("@deepseek-ai/dsh-tools").ToolDefinition;
+/** Tool: list all registered projects. */
+export declare function listProjectsTool(scope: DevDockScope): import("@deepseek-ai/dsh-tools").ToolDefinition;
+/** Tool: remove one project from the registry (cascades quick-start references). */
+export declare function removeProjectTool(scope: DevDockScope): import("@deepseek-ai/dsh-tools").ToolDefinition;
+//# sourceMappingURL=project.d.ts.map

package/lib/types/tools/scan.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Deterministic directory scan for frontend project candidates. The tool
+ * returns raw signals only — the AI decides which candidates are frontend
+ * projects and what their environment is.
+ * @module @liyuera/dsh-dev-dock/tools/scan
+ */
+/** Signals one candidate directory exposes for AI judgment. */
+export interface CandidateSignals {
+    /** Absolute candidate path. */
+    path: string;
+    /** Directory basename. */
+    name: string;
+    /** Has package.json (Node project marker). */
+    hasPackageJson: boolean;
+    /** Has manifest.json or src/manifest.json (uni-app marker). */
+    hasManifest: boolean;
+    /** Has project.config.json or miniprogramRoot (miniapp marker). */
+    hasMiniappConfig: boolean;
+    /** Lock file name when present. */
+    lockFile?: string;
+    /** Has .nvmrc or .node-version. */
+    hasNodeVersionFile: boolean;
+    /** Top-level dependencies present in package.json (vue/react/taro/uni-app etc.). */
+    dependencies: string[];
+    /** script names from package.json. */
+    scriptNames: string[];
+    /** package.json description when present. */
+    description?: string;
+}
+/**
+ * Collect signals for one candidate directory.
+ * @param dir - absolute candidate directory.
+ * @returns candidate signals.
+ */
+export declare function collectSignals(dir: string): CandidateSignals;
+/**
+ * Scan one directory: the directory itself plus its direct children.
+ * @param root - absolute directory to scan.
+ * @returns candidate signals for the root and each direct subdirectory.
+ */
+export declare function scanCandidates(root: string): CandidateSignals[];
+/** Model-facing tool: scan one directory for frontend project candidates. */
+export declare const scanCandidatesTool: import("@deepseek-ai/dsh-tools").ToolDefinition;
+//# sourceMappingURL=scan.d.ts.map

package/package.json

@@ -1,6 +1,87 @@
 {
   "name": "@liyuera/dsh-dev-dock",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "Frontend project engineering management for dsh: project registry, editor detection, quick-start, open project in IDE or system terminal",
+  "version": "1.0.3",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ],
+      "platform": "web"
+    }
+  },
+  "scripts": {
+    "bundle": "tsdown --config-loader tsx",
+    "watch": "tsdown --watch --config-loader tsx"
+  },
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/liyuera/deepseek-harness-plugin.git",
+    "directory": "dev-dock"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "clsx": "^2.0.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-client-locale": "^0.1.2-alpha.4",
+    "@deepseek-ai/dsh-client-store": "^0.1.2-alpha.4",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.2-alpha.4",
+    "@deepseek-ai/dsh-client-ui-layout": "^0.1.2-alpha.4",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.2-alpha.4",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.1.2-alpha.4",
+    "@deepseek-ai/dsh-client-ui-sidebar": "^0.1.2-alpha.4",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.2-alpha.4",
+    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.4",
+    "@deepseek-ai/dsh-native-command": "^0.1.2-alpha.4",
+    "@deepseek-ai/dsh-session": "^0.1.2-alpha.4",
+    "@deepseek-ai/dsh-storage-domain": "^0.1.6-alpha.2",
+    "@deepseek-ai/schemastery": "^3.18.2",
+    "@testing-library/react": "^16.3.2",
+    "@types/react": "~18.3.1",
+    "@types/react-dom": "~18.3.1",
+    "react": "^18.2.0",
+    "react-dom": "^18.3.1",
+    "zod": "^4.4.3"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/client.js",
+    "lib/types/**/*.d.ts",
+    "cordis.patch.yml"
+  ]
+}