dsh-cmdk 0.0.0-stage → 0.3.2

package/cordis.patch.yml

@@ -0,0 +1,5 @@
+# dsh-cmdk: hosts the ⌘K palette (client) and two small host routes
+# (profile directory lookup + native folder open).
+- insert:
+    - id: dsh-cmdk
+      name: dsh-cmdk

package/icon.svg

@@ -0,0 +1,16 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64" fill="none">
+  <defs>
+    <linearGradient id="g" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0" stop-color="#5B6CF9"/>
+      <stop offset="1" stop-color="#8E5BF6"/>
+    </linearGradient>
+  </defs>
+  <rect x="0" y="0" width="64" height="64" rx="15" fill="url(#g)"/>
+  <rect x="13" y="15" width="38" height="26" rx="7" fill="#FFFFFF" fill-opacity="0.96"/>
+  <rect x="19" y="23" width="14" height="2.6" rx="1.3" fill="#5B6CF9"/>
+  <rect x="19" y="29" width="22" height="2.6" rx="1.3" fill="#C9CEF8"/>
+  <rect x="19" y="35" width="9" height="2.6" rx="1.3" fill="#C9CEF8"/>
+  <circle cx="43" cy="43" r="8.5" fill="#FFFFFF" fill-opacity="0.96"/>
+  <circle cx="43" cy="43" r="5" stroke="#5B6CF9" stroke-width="2.4"/>
+  <rect x="46.6" y="47.4" width="7" height="2.6" rx="1.3" transform="rotate(45 46.6 47.4)" fill="#5B6CF9"/>
+</svg>

package/index.js

@@ -0,0 +1,443 @@
+/**
+ * dsh-cmdk — host half.
+ *
+ * The palette itself is client-only (navigation, theme and workspace state all
+ * live on the Client side). The Host half exists for the things a browser
+ * sandbox cannot reach:
+ *
+ *   GET  /cmdk/info           → where this profile lives (home + profile dir)
+ *   GET  /cmdk/sessions?q=    → full session catalogue + message-content hits
+ *   POST /cmdk/open-profile   → reveal the profile directory in Finder/Explorer
+ *   GET  /cmdk/plugins        → installed bundles (name, version, enabled, dir)
+ *   POST /cmdk/plugin         → enable/disable one bundle via pluginManager
+ *
+ * Every route goes through the connection trust fence first, so a random page
+ * cannot probe the host filesystem through the loopback port.
+ */
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const name = 'dsh-cmdk';
+export const inject = ['webServer'];
+
+const ROUTE = '/cmdk';
+
+/** How long the session title catalogue stays warm between keystrokes. */
+const CATALOG_TTL = 20_000;
+const CATALOG_SIZE = 120;
+/** How many of the newest sessions the content scan looks at per query. */
+const CONTENT_SCAN_SIZE = 12;
+
+let catalogCache = { at: 0, items: [] };
+/** Query → content hits, so held-down keys do not rescan the logs every 180 ms. */
+const contentCache = new Map();
+const CONTENT_TTL = 60_000;
+
+function dshHome() {
+  const fromEnv = process.env.DSH_HOME;
+  return fromEnv && fromEnv.trim() ? fromEnv : path.join(os.homedir(), '.dsh');
+}
+
+/** Best-effort running profile directory (same order as the rest of the UI): env dir → env name → desktop. */
+function profileDir() {
+  const dir = process.env.DSH_PROFILE_DIR;
+  if (dir && dir.trim()) return dir;
+  const profile = process.env.DSH_PROFILE;
+  if (profile && profile.trim()) return path.join(dshHome(), 'profiles', profile);
+  return path.join(dshHome(), 'profiles', 'desktop');
+}
+
+function sendJson(res, code, payload) {
+  const body = Buffer.from(JSON.stringify(payload), 'utf8');
+  res.writeHead(code, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Cache-Control': 'no-store',
+    'Content-Length': String(body.length),
+  });
+  res.end(body);
+}
+
+function readBody(req, limit = 16 * 1024) {
+  return new Promise((resolve) => {
+    let size = 0;
+    const chunks = [];
+    req.on('data', (chunk) => {
+      size += chunk.length;
+      if (size > limit) {
+        req.destroy();
+        resolve('');
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    req.on('error', () => resolve(''));
+  });
+}
+
+/** Returns true when the request was already rejected (and answered). */
+function refused(ctx, req, res) {
+  const conn = ctx.get('connection') || ctx.connection;
+  if (!conn || typeof conn.requestRejection !== 'function') return false;
+  const code = conn.requestRejection({ headers: req.headers });
+  if (code === undefined || code === null || code === false) return false;
+  res.statusCode = typeof code === 'number' ? code : 403;
+  res.end();
+  return true;
+}
+
+function openInFileManager(dir) {
+  const [command, args] =
+    process.platform === 'darwin'
+      ? ['open', [dir]]
+      : process.platform === 'win32'
+        ? ['explorer', [dir]]
+        : ['xdg-open', [dir]];
+  return new Promise((resolve, reject) => {
+    execFile(command, args, (error) => (error ? reject(error) : resolve()));
+  });
+}
+
+/** Session ids are brand types at the type level but plain strings at runtime. */
+function idOf(record) {
+  return record && record.header && record.header.id ? String(record.header.id) : '';
+}
+
+/** Fold titles for a batch of ids; missing titles come back as ''. */
+async function titlesFor(query, ids) {
+  const out = new Map();
+  if (!ids.length || typeof query.readTitleSnapshots !== 'function') return out;
+  let results = [];
+  try {
+    results = await query.readTitleSnapshots(ids);
+  } catch {
+    return out;
+  }
+  for (const result of results || []) {
+    if (!result || result.status !== 'fulfilled' || !result.value || !result.value.title) continue;
+    const title = result.value.title.title;
+    if (typeof title === 'string' && title.trim()) out.set(String(result.sessionId), title.trim());
+  }
+  return out;
+}
+
+/**
+ * Human-facing sessions: no subagent branches, no seeded placeholders, and
+ * never more than CATALOG_SIZE entries. Cached briefly so typing in the
+ * palette does not re-read every log on each keystroke.
+ */
+async function sessionCatalog(ctx) {
+  const now = Date.now();
+  if (now - catalogCache.at < CATALOG_TTL && catalogCache.items.length) return catalogCache.items;
+
+  const query = ctx.get('sessionQuery');
+  if (!query || typeof query.listSessions !== 'function') return [];
+
+  let records = [];
+  try {
+    records = await query.listSessions();
+  } catch {
+    return catalogCache.items;
+  }
+
+  const picked = (records || [])
+    .filter((record) => {
+      const header = record && record.header;
+      if (!header || !header.id) return false;
+      if (header.origin === 'subagent' || header.parentSession) return false;
+      if (header.isSeeded) return false;
+      return true;
+    })
+    .slice(0, CATALOG_SIZE);
+
+  const titles = await titlesFor(query, picked.map(idOf).filter(Boolean));
+  const items = picked
+    .map((record) => {
+      const sessionId = idOf(record);
+      return {
+        sessionId,
+        title: titles.get(sessionId) || '',
+        cwd: record.header && record.header.cwd ? record.header.cwd : '',
+        at: record.header && record.header.createdAt ? record.header.createdAt : 0,
+        snippet: '',
+      };
+    })
+    .filter((item) => item.sessionId);
+
+  catalogCache = { at: now, items };
+  return items;
+}
+
+/**
+ * Content hits. The SQLite full-text index can be empty in the wild (the
+ * native session search reports "no matches" on such machines), so this walks
+ * the newest sessions and uses the backend-independent `filterEvents` text
+ * predicate instead: no index required, just the session logs.
+ */
+async function matchContent(ctx, text, limit) {
+  const query = ctx.get('sessionQuery');
+  if (!query || typeof query.filterEvents !== 'function') return [];
+  if (text.length < 2) return [];
+
+  const cached = contentCache.get(text);
+  if (cached && Date.now() - cached.at < CONTENT_TTL) return cached.items.slice(0, limit);
+  const catalog = await sessionCatalog(ctx);
+  const scan = catalog.slice(0, CONTENT_SCAN_SIZE);
+
+  const hits = [];
+  for (const item of scan) {
+    let documents = [];
+    try {
+      documents = await query.filterEvents(item.sessionId, [{ kind: 'text', text }]);
+    } catch {
+      continue;
+    }
+    if (!Array.isArray(documents) || !documents.length) continue;
+    const doc = documents.find((entry) => entry && typeof entry.text === 'string');
+    if (!doc) continue;
+    hits.push({
+      sessionId: item.sessionId,
+      title: item.title,
+      cwd: item.cwd,
+      at: item.at,
+      snippet: snippetAround(doc.text, text),
+    });
+    if (hits.length >= limit) break;
+  }
+  if (contentCache.size > 40) contentCache.clear();
+  contentCache.set(text, { at: Date.now(), items: hits });
+  return hits;
+}
+
+/** 40 chars either side of the match, whitespace collapsed. */
+function snippetAround(text, needle) {
+  const flat = String(text || '').replace(/\s+/g, ' ');
+  const at = flat.toLowerCase().indexOf(String(needle).toLowerCase());
+  if (at < 0) return flat.slice(0, 120);
+  const from = Math.max(0, at - 40);
+  const to = Math.min(flat.length, at + needle.length + 60);
+  return (from > 0 ? '…' : '') + flat.slice(from, to) + (to < flat.length ? '…' : '');
+}
+
+
+function workspaceStorePath() {
+  return path.join(dshHome(), 'storages', 'workspace.json');
+}
+
+/** Workspaces live in the Client store; read the same file without touching it. */
+function readWorkspaces() {
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(workspaceStorePath(), 'utf8'));
+  } catch {
+    return { items: [], archived: [] };
+  }
+  if (!raw || typeof raw !== 'object') return { items: [], archived: [] };
+  const global = raw.global && typeof raw.global === 'object' ? raw.global : {};
+  const table = (raw.tables && raw.tables.workspaces) || {};
+  const items = [];
+  for (const id of Array.isArray(global.workspaceIds) ? global.workspaceIds : Object.keys(table)) {
+    const row = table[id];
+    if (!row) continue;
+    items.push({
+      workspaceId: id,
+      title: typeof row.title === 'string' ? row.title : '',
+      path: typeof row.path === 'string' ? row.path : '',
+      sessionIds: Array.isArray(row.sessionIds) ? row.sessionIds : [],
+    });
+  }
+  return {
+    items,
+    archived: Array.isArray(global.archivedSessionIds) ? global.archivedSessionIds.slice() : [],
+  };
+}
+
+export function apply(ctx, config) {
+  const server = ctx.get('webServer') || ctx.webServer;
+  if (!server || typeof server.register !== 'function') {
+    ctx.logger?.warn?.('dsh-cmdk: no webServer carrier, palette routes unavailable');
+    return;
+  }
+
+  const disposers = [];
+
+  disposers.push(
+    server.register({
+      kind: 'exact',
+      path: ROUTE + '/info',
+      handler: async (req, res) => {
+        if (refused(ctx, req, res)) return;
+        sendJson(res, 200, {
+          ok: true,
+          home: dshHome(),
+          profile: profileDir(),
+          platform: process.platform,
+          arch: process.arch,
+        });
+      },
+    }),
+  );
+
+  disposers.push(
+    server.register({
+      kind: 'exact',
+      path: ROUTE + '/sessions',
+      handler: async (req, res) => {
+        if (refused(ctx, req, res)) return;
+        let url;
+        try {
+          url = new URL(req.url || ROUTE, 'http://localhost');
+        } catch {
+          sendJson(res, 400, { ok: false, error: 'bad url' });
+          return;
+        }
+        const text = (url.searchParams.get('q') || '').trim();
+        const asked = Number(url.searchParams.get('limit'));
+        const limit = Number.isFinite(asked) && asked > 0 ? Math.min(asked, 50) : 20;
+
+        try {
+          const catalog = await sessionCatalog(ctx);
+          if (!text) {
+            sendJson(res, 200, { ok: true, items: catalog, hits: [], total: catalog.length });
+            return;
+          }
+          // The client filters titles locally (fuzzy + pinyin); the Host only
+          // contributes the expensive part: message-content hits.
+          const hits = await matchContent(ctx, text, limit);
+          sendJson(res, 200, { ok: true, items: catalog, hits, total: catalog.length });
+        } catch (error) {
+          sendJson(res, 500, { ok: false, error: String((error && error.message) || error) });
+        }
+      },
+    }),
+  );
+
+  disposers.push(
+    server.register({
+      kind: 'exact',
+      path: ROUTE + '/workspaces',
+      handler: (req, res) => {
+        if (refused(ctx, req, res)) return;
+        try {
+          const data = readWorkspaces();
+          sendJson(res, 200, { ok: true, items: data.items, archived: data.archived });
+        } catch (error) {
+          sendJson(res, 500, { ok: false, error: String((error && error.message) || error) });
+        }
+      },
+    }),
+  );
+
+  disposers.push(
+    server.register({
+      kind: 'exact',
+      path: ROUTE + '/open-profile',
+      handler: async (req, res) => {
+        if (refused(ctx, req, res)) return;
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, error: 'POST only' });
+          return;
+        }
+        const raw = await readBody(req);
+        let target = profileDir();
+        if (raw) {
+          try {
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed.path === 'string' && parsed.path.trim()) {
+              target = parsed.path.trim();
+            }
+          } catch {
+            /* fall back to the profile directory */
+          }
+        }
+        try {
+          await openInFileManager(target);
+          sendJson(res, 200, { ok: true, path: target });
+        } catch (error) {
+          sendJson(res, 500, { ok: false, error: String(error && error.message ? error.message : error) });
+        }
+      },
+    }),
+  );
+
+  disposers.push(
+    server.register({
+      kind: 'exact',
+      path: ROUTE + '/plugins',
+      handler: async (req, res) => {
+        if (refused(ctx, req, res)) return;
+        try {
+          const manager = ctx.get('pluginManager') || ctx.pluginManager;
+          const bundles = manager && typeof manager.listBundles === 'function' ? await manager.listBundles() : [];
+          const items = bundles
+            .filter((bundle) => bundle && bundle.installed && bundle.availability !== 'installation')
+            .map((bundle) => ({
+              name: bundle.name,
+              version: bundle.version || '',
+              enabled: !!bundle.enabled,
+              dir: path.join(profileDir(), 'node_modules', ...bundle.name.split('/')),
+            }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+          sendJson(res, 200, { ok: true, items });
+        } catch (error) {
+          sendJson(res, 500, { ok: false, error: String((error && error.message) || error) });
+        }
+      },
+    }),
+  );
+
+  disposers.push(
+    server.register({
+      kind: 'exact',
+      path: ROUTE + '/plugin',
+      handler: async (req, res) => {
+        if (refused(ctx, req, res)) return;
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, error: 'POST only' });
+          return;
+        }
+        const raw = await readBody(req);
+        let body = null;
+        try {
+          body = raw ? JSON.parse(raw) : null;
+        } catch {
+          sendJson(res, 400, { ok: false, error: 'invalid json' });
+          return;
+        }
+        const name = body && typeof body.name === 'string' ? body.name.trim() : '';
+        if (!name) {
+          sendJson(res, 400, { ok: false, error: 'missing name' });
+          return;
+        }
+        const manager = ctx.get('pluginManager') || ctx.pluginManager;
+        if (!manager || typeof manager.setBundleEnabled !== 'function') {
+          sendJson(res, 503, { ok: false, error: 'plugin manager unavailable' });
+          return;
+        }
+        try {
+          const result = await manager.setBundleEnabled(name, !!body.enabled);
+          sendJson(res, 200, {
+            ok: !result.error,
+            changed: result.changed,
+            application: result.application,
+            error: result.error ? result.error.code || 'failed' : undefined,
+          });
+        } catch (error) {
+          sendJson(res, 500, { ok: false, error: String((error && error.message) || error) });
+        }
+      },
+    }),
+  );
+
+  ctx.effect(() => () => {
+    for (const dispose of disposers) {
+      try {
+        dispose();
+      } catch {
+        /* already gone */
+      }
+    }
+  });
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "⌘K Command Palette",
+    "description": "One shortcut to any session: search titles and message content, switch workspaces, start a new session or theme — without touching the mouse."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "⌘K 命令面板",
+    "description": "一个快捷键跳到任何会话：搜标题、搜消息内容、切工作区、开新会话、换外观，都不用离开键盘。"
+  }
+}

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "dsh-cmdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.2",
+  "type": "module",
+  "description": "⌘K command palette for DeepSeek Harness: jump to sessions, search message content, switch workspaces, toggle plugins.",
+  "icon": "icon.svg",
+  "keywords": [
+    "dsh",
+    "command-palette",
+    "search",
+    "productivity"
+  ],
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "screenshot.png",
+    "screenshot-actions.png",
+    "screenshot-ext.png",
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-layout"
+      ]
+    }
+  },
+  "license": "MIT",
+  "author": "mumuhmumu",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hhse/dsh-cmdk.git"
+  },
+  "homepage": "https://github.com/hhse/dsh-cmdk#readme",
+  "bugs": {
+    "url": "https://github.com/hhse/dsh-cmdk/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}