claude-code-hub 1.26.0 → 1.27.1

package/features/voice/feature.json

@@ -0,0 +1,42 @@
+{
+  "manifest": 1,
+  "kind": "feature",
+  "id": "voice",
+  "title": "Voice control",
+  "requires": {
+    "hub": "1.27.0",
+    "apps": ["kanban"],
+    "tools": [
+      {
+        "name": "Hex",
+        "check": "voice.hex",
+        "url": "https://anoma.ly/hex",
+        "optional": true,
+        "without": "Voice uses the browser's speech recognition, which is online. Install Hex to keep speech on your machine."
+      }
+    ]
+  },
+  "config": { "voice": { "enabled": true } },
+  "listing": {
+    "tagline": "Hold a key and speak: start a session or send a prompt with no Enter press",
+    "description": "Hold Ctrl+Shift+Space, speak and let go. \"New session, fix the flaky test\" opens the New session dialog with that prompt, and anything else goes to the session on screen as a prompt and is submitted. Kanban's New session microphone uses the same speech to text. Hex does the speech to text on your machine; without it, the browser's speech recognition does it.",
+    "tags": ["voice", "experimental"],
+    "screenshots": [
+      {
+        "url": "https://nikiforovall.blog/claude-code-hub/shots/extensions/voice-live-new-session.webp",
+        "alt": "Kanban's New session dialog opened by voice while the user still speaks: the Prompt field shows \"Fix the flaky login test and then run the\" and a Listening pill sits at the bottom of the hub window",
+        "title": "Words show up as you speak",
+        "caption": "\"New session\" opens the dialog at once, and the rest of what you say fills the Prompt field.",
+        "card": true
+      },
+      {
+        "url": "https://nikiforovall.blog/claude-code-hub/shots/extensions/voice-hex.webp",
+        "alt": "The Hex website: \"Speak. It appears.\", local voice dictation for Windows, with the Windows installer and a PowerShell install command",
+        "title": "Hex does the speech to text",
+        "caption": "Install Hex and start it once. It runs on your machine, and the hub sends it the sound while you hold the keys."
+      }
+    ],
+    "homepage": "https://nikiforovall.blog/claude-code-hub/guides/voice/",
+    "license": "MIT"
+  }
+}

package/lib/ext.js

@@ -25,6 +25,8 @@ const USAGE = `Usage: claude-code-hub ext <command>
   A Kanban dock add-on (addon.json) installs the same way: in place of a plugin, it goes on the
   Kanban dock of the config dir, for every session.
 
+  A feature the hub ships (voice) is turned on by ext install <id> and off by ext remove <id>.
+
   --hub-dir <path>       The hub dir (default CLAUDE_HUB_DIR, else ~/.claude-hub)
   --dir <path>           The config dir for plugin and dock steps (default CLAUDE_CONFIG_DIR, else ~/.claude)`;
 
@@ -270,10 +272,56 @@ function install(ctx, target) {
   if (app) return installAppPlugin(ctx, app);
   const [addon] = extEntries(config).find(([e, k]) => k === KINDS.addon && e.id === target) ?? [];
   if (addon) return dockStep(ctx, target, null, 'install', rootOf(ctx, addon), config);
+  const feature = readFeature(target, ctx.features);
+  if (feature) return setFeature(ctx, feature, true, file, config);
   if (!fs.existsSync(target) && ID_RE.test(target)) return installRegistry(ctx, target, file, config);
   return installFolder(ctx, target, file, config);
 }
 
+// A feature is code the hub ships, off by default: `ext install` checks what it needs and merges its
+// `config` into config.json; `ext remove` sets `enabled: false` in each of those keys and keeps the rest.
+const FEATURES = path.join(HUB_ROOT, 'features');
+const TOOL_CHECKS = {
+  'voice.hex': () => !!require('./voice/hex').hexExe(),
+};
+const OS_NAMES = { win32: 'Windows', darwin: 'macOS', linux: 'Linux' };
+
+function readFeature(id, features = FEATURES) {
+  if (!ID_RE.test(id ?? '')) return null;
+  const file = path.join(features, id, 'feature.json');
+  if (!fs.existsSync(file)) return null;
+  const manifest = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (manifest.kind !== 'feature' || manifest.id !== id || typeof manifest.config !== 'object') {
+    throw new Error(`${file}: a feature manifest needs "kind": "feature", the id ${id} and a config object`);
+  }
+  return manifest;
+}
+
+function setFeature(ctx, feature, on, file, config) {
+  const { id, title = id, requires = {} } = feature;
+  if (on) {
+    // The hub ships the feature, so its hub version is this one.
+    checkRequires(ctx, { id, requires: { ...requires, hub: undefined } }, config);
+    const platform = ctx.platform ?? process.platform;
+    if (requires.os && !requires.os.includes(platform)) {
+      throw new Error(`Cannot use ${id}: it runs on ${requires.os.map((o) => OS_NAMES[o] ?? o).join(' or ')} only.`);
+    }
+    const checks = { ...TOOL_CHECKS, ...ctx.toolChecks };
+    const absent = (requires.tools ?? []).filter((t) => !checks[t.check]?.());
+    const named = (t) => (t.url ? `${t.name} (${t.url})` : t.name);
+    const missing = absent.filter((t) => !t.optional);
+    if (missing.length) throw new Error(`Cannot use ${id}: install ${missing.map(named).join(' and ')} first.`);
+    for (const t of absent.filter((t) => t.optional)) console.log(`\n  ${named(t)} is not installed. ${t.without ?? ''}`.trimEnd());
+  }
+  const next = { ...config };
+  for (const [key, value] of Object.entries(feature.config)) {
+    next[key] = on ? { ...config[key], ...value } : { ...config[key], enabled: false };
+  }
+  writeConfigFile(file, next);
+  console.log(`\n  ${title} is ${on ? 'on' : 'off'}.\n${RESTART}`);
+  return true;
+}
+
 // fetch is async and ext runs synchronously, so a child node reads the index.
 const FETCH =
   'fetch(process.argv[1]).then(async (r) => { if (!r.ok) throw new Error(`HTTP ${r.status}`); process.stdout.write(await r.text()); })' +
@@ -454,6 +502,8 @@ function update(ctx, id) {
 
 function remove(ctx, id) {
   const { file, config } = readConfig(ctx.hubDir);
+  const feature = readFeature(id, ctx.features);
+  if (feature) return setFeature(ctx, feature, false, file, config);
   const [entry, kind] = managedEntry(config, id, 'be removed');
   const root = rootOf(ctx, entry);
   let ext = null;

package/lib/keymap.js

@@ -10,6 +10,7 @@ const HUB_ACTIONS = [
   'hub.prevApp',
   'hub.nextApp',
   'hub.appByNumber',
+  'hub.voice',
 ];
 // {n} stands for the tab number, 1 to 9.
 const PATTERN_ACTIONS = new Set(['hub.appByNumber']);

package/lib/voice/grammar.js

@@ -0,0 +1,77 @@
+'use strict';
+
+// Decider: a few fixed phrases, no network. Gives null for anything else, so the next decider can
+// try it. A command starts with the reserved word "hub", so a prompt never turns into one.
+const norm = (s) =>
+  String(s ?? '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, ' ')
+    .trim();
+
+// Speech services often hear "hub" as these.
+const PREFIX = /^\s*(?:hub|hob|hab)\b[\s,.:;!?-]*/i;
+
+const TAIL = '\\b[\\s,.:;!?-]*([\\s\\S]*?)\\s*$';
+const phrase = (verbs, noun) =>
+  new RegExp(`^(?:(?:${verbs})\\s+(?:(?:a|the)\\s+)?(?:new\\s+)?)?${noun}${TAIL}`, 'i');
+const dropEndPunct = (s) => s.replace(/[.!?]+$/, '');
+
+// `param` takes the words after the phrase; `tidy` cleans them. `say` and `help` feed the page's help panel.
+// `live` names the app's dialog action that the page fills as the user speaks, and the param that takes
+// the words so far.
+const COMMANDS = [
+  {
+    action: 'session.new',
+    label: 'New session',
+    phrase: phrase('start|create|new', 'session'),
+    param: 'prompt',
+    say: 'new session',
+    help: 'Opens New session with your prompt',
+  },
+  {
+    action: 'session.find',
+    label: 'Open session',
+    phrase: new RegExp(`^(?:open|switch\\s+to|go\\s+to|show)\\s+(?:(?:the|my)\\s+)?session${TAIL}`, 'i'),
+    param: 'name',
+    tidy: dropEndPunct,
+    say: 'open session',
+    help: 'Opens the session that matches',
+  },
+  {
+    action: 'task.add',
+    label: 'Add task',
+    phrase: phrase('add|create|new', 'task'),
+    param: 'subject',
+    tidy: dropEndPunct,
+    say: 'add a task',
+    help: 'Opens Add task with your words',
+    live: { action: 'task.live', param: 'description' },
+  },
+];
+
+const commandList = () =>
+  COMMANDS.map(({ action, label, param, say, help, live }) => ({ action, label, param, say, help, live }));
+
+// {action, label, param, rest} for the first command an app handles, else null. After the prefix
+// with no such command yet, action is null: the words are still not a prompt.
+function matchCommand(text, can = () => true) {
+  const said = String(text ?? '');
+  const prefix = PREFIX.exec(said);
+  if (!prefix) return null;
+  const body = said.slice(prefix[0].length);
+  for (const c of COMMANDS) {
+    const m = c.phrase.exec(body);
+    if (!m || !can(c.action)) continue;
+    return { action: c.action, label: c.label, param: c.param, live: c.live, rest: c.tidy ? c.tidy(m[1]) : m[1] };
+  }
+  return { action: null, label: 'Hub', rest: body.trim() };
+}
+
+async function grammar(ctx) {
+  const m = matchCommand(ctx.text, ctx.can);
+  if (!m) return null;
+  if (!m.action) return { kind: 'unknown' };
+  return { kind: 'invoke', action: m.action, params: m.rest ? { [m.param]: m.rest } : {}, label: m.label };
+}
+
+module.exports = { grammar, matchCommand, norm, commandList };

package/lib/voice/hex-stream.js

@@ -0,0 +1,155 @@
+'use strict';
+
+// Live speech through the Hex app's local API (/streams): the hub page sends mic audio, Hex sends
+// partial text back. The bearer token and the stream's owner token stay in the hub.
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SAMPLE_RATE = 16000;
+// Hex drops a stream whose lease (10 s) runs out with no call.
+const HEARTBEAT_MS = 4000;
+
+function readApi(file) {
+  try {
+    const api = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return api.port && api.token ? api : null;
+  } catch {
+    return null;
+  }
+}
+
+const failOf = (r) => ({ ok: false, error: r.json.error || `Hex answered ${r.status}` });
+
+function createHexStream({ apiFile = path.join(process.env.APPDATA || '', 'hex', 'local-api.json'), fetchImpl = fetch } = {}) {
+  let live = null;
+
+  async function call(method, url, { headers = {}, body, signal } = {}) {
+    const r = await fetchImpl(url, { method, headers, body, signal });
+    const text = await r.text();
+    let json = {};
+    try {
+      json = text ? JSON.parse(text) : {};
+    } catch {}
+    return { status: r.status, ok: r.ok, json };
+  }
+
+  function textOf(s) {
+    const done = s.segments.filter((t, i) => t && i < s.current);
+    return [...done, s.partial].filter(Boolean).join(' ').trim();
+  }
+
+  function onEvent(s, e) {
+    if (e.type === 'partial') {
+      s.current = e.segment;
+      s.partial = `${e.stable ?? ''}${e.tentative ?? ''}`;
+    } else if (e.type === 'segment') {
+      s.segments[e.segment] = e.text;
+      if (e.segment >= s.current) {
+        s.current = e.segment + 1;
+        s.partial = '';
+      }
+    }
+    s.text = textOf(s);
+  }
+
+  async function listen(s) {
+    try {
+      const r = await fetchImpl(`${s.base}/streams/${s.id}/events`, { headers: s.headers, signal: s.abort.signal });
+      const dec = new TextDecoder();
+      let buf = '';
+      for await (const chunk of r.body) {
+        buf += dec.decode(chunk, { stream: true });
+        let i = buf.indexOf('\n\n');
+        while (i >= 0) {
+          const data = buf.slice(0, i).split('\n').find((l) => l.startsWith('data:'));
+          buf = buf.slice(i + 2);
+          if (data) {
+            try {
+              onEvent(s, JSON.parse(data.slice(5)));
+            } catch {}
+          }
+          i = buf.indexOf('\n\n');
+        }
+      }
+    } catch {}
+  }
+
+  function end(s) {
+    clearInterval(s.heartbeat);
+    s.abort.abort();
+    if (live === s) live = null;
+  }
+
+  // {ok, unsupported?}: unsupported means fall back to the CLI (no local API, or no /streams).
+  async function start() {
+    if (live) await cancel();
+    const api = readApi(apiFile);
+    if (!api) return { ok: false, unsupported: true, error: 'Hex local API not found' };
+    const base = `http://127.0.0.1:${api.port}`;
+    const auth = { Authorization: `Bearer ${api.token}` };
+    let r;
+    try {
+      r = await call('POST', `${base}/streams`, {
+        headers: { ...auth, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ sampleFormat: 'f32le', sampleRate: SAMPLE_RATE }),
+      });
+    } catch (err) {
+      return { ok: false, unsupported: true, error: err.message };
+    }
+    if (r.status === 404) return { ok: false, unsupported: true, error: 'Hex has no /streams' };
+    if (!r.ok) return failOf(r);
+    const s = {
+      base,
+      id: r.json.id,
+      headers: { ...auth, 'X-Hex-Stream-Token': r.json.ownerToken },
+      abort: new AbortController(),
+      segments: [],
+      current: 0,
+      partial: '',
+      text: '',
+    };
+    s.heartbeat = setInterval(() => {
+      call('POST', `${base}/streams/${s.id}/heartbeat`, { headers: s.headers }).catch(() => {});
+    }, HEARTBEAT_MS);
+    live = s;
+    listen(s);
+    return { ok: true, sampleRate: SAMPLE_RATE };
+  }
+
+  async function audio(buf) {
+    const s = live;
+    if (!s) return { ok: false, error: 'no live stream' };
+    const r = await call('POST', `${s.base}/streams/${s.id}/audio`, {
+      headers: { ...s.headers, 'Content-Type': 'application/octet-stream' },
+      body: buf,
+    }).catch((err) => ({ ok: false, json: { error: err.message } }));
+    if (!r.ok) return failOf(r);
+    return { ok: true, text: s.text };
+  }
+
+  async function finish() {
+    const s = live;
+    if (!s) return { ok: false, error: 'no live stream' };
+    try {
+      const r = await call('POST', `${s.base}/streams/${s.id}/finish`, { headers: { ...s.headers, 'Content-Length': '0' } });
+      if (!r.ok) return failOf(r);
+      return { ok: true, text: (r.json.text ?? '').trim() };
+    } catch (err) {
+      return { ok: false, error: err.message };
+    } finally {
+      end(s);
+    }
+  }
+
+  async function cancel() {
+    const s = live;
+    if (!s) return { ok: true };
+    end(s);
+    await call('POST', `${s.base}/streams/${s.id}/cancel`, { headers: s.headers }).catch(() => {});
+    return { ok: true };
+  }
+
+  return { start, audio, finish, cancel };
+}
+
+module.exports = { createHexStream };

package/lib/voice/hex.js

@@ -0,0 +1,53 @@
+'use strict';
+
+// Speech provider: the Hex app's CLI (https://github.com/anomalyco/hex).
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+
+// Hex keeps one folder per version and names the current one in current-version.
+function hexExe(root = path.join(process.env.APPDATA || '', 'hex')) {
+  if (process.env.HEX_EXE) return process.env.HEX_EXE;
+  try {
+    const v = fs.readFileSync(path.join(root, 'current-version'), 'utf8').trim();
+    const exe = path.join(root, 'versions', v, process.platform === 'win32' ? 'hex.exe' : 'hex');
+    return fs.existsSync(exe) ? exe : null;
+  } catch {
+    return null;
+  }
+}
+
+function run(cmd, args, timeoutMs) {
+  return new Promise((resolve) => {
+    const p = spawn(cmd, args, { windowsHide: true });
+    let out = '';
+    let err = '';
+    const timer = setTimeout(() => p.kill(), timeoutMs);
+    p.stdout.on('data', (d) => (out += d));
+    p.stderr.on('data', (d) => (err += d));
+    p.on('error', (e) => {
+      clearTimeout(timer);
+      resolve({ code: -1, out, err: e.message });
+    });
+    p.on('close', (code) => {
+      clearTimeout(timer);
+      resolve({ code, out, err });
+    });
+  });
+}
+
+// `dictation stop --print` prints the transcript, and exits 4 when Hex heard no speech.
+function createHex({ exe = hexExe() } = {}) {
+  async function call(action) {
+    if (!exe) return { ok: false, error: 'Hex is not installed' };
+    const args = action === 'stop' ? ['dictation', 'stop', '--print'] : ['dictation', action];
+    const r = await run(exe, args, 70_000);
+    const error = r.code ? (r.err || r.out).trim() || `hex exited ${r.code}` : undefined;
+    if (action !== 'stop') return { ok: !r.code, error };
+    if (r.code === 4) return { ok: true, text: '' };
+    return { ok: !r.code, text: r.out.trim(), error };
+  }
+  return { start: () => call('start'), stop: () => call('stop'), cancel: () => call('cancel') };
+}
+
+module.exports = { createHex, hexExe };

package/lib/voice/index.js

@@ -0,0 +1,111 @@
+'use strict';
+
+// Voice control: a speech provider gives text, deciders turn it into a command for the hub page.
+// A command is {kind: 'invoke', action, params, label?} | {kind: 'none'} | {kind: 'unknown'}.
+// The local grammar runs first; a decider named in voice.decider gets only what the grammar did not
+// know. Text no decider takes is a prompt: pasted into the session on screen as a draft. The page
+// sends it when the user pressed Enter during the hold.
+// The browser provider runs the browser's speech recognition on the hub page, which posts the text
+// to text(); the server only decides. auto picks Hex when it is installed, else the browser.
+const { createHex, hexExe } = require('./hex');
+const { createHexStream } = require('./hex-stream');
+const { grammar, matchCommand, norm, commandList } = require('./grammar');
+const { titleTask, askClaude } = require('./title');
+
+const SPEECH = { hex: createHex };
+const STREAMS = { hex: () => createHexStream() };
+const DECIDERS = { grammar: () => grammar };
+const PROVIDERS = ['auto', 'hex', 'browser'];
+const IN_BROWSER = async () => ({ ok: false, error: 'speech runs in the browser' });
+
+function resolveProvider(name = 'auto', hasHex = () => !!hexExe()) {
+  if (!PROVIDERS.includes(name)) throw new Error(`unknown voice provider ${name}`);
+  return name === 'auto' ? (hasHex() ? 'hex' : 'browser') : name;
+}
+
+// cfg: config.json `voice`. ctx(): {apps, actions} for one decision, read per call.
+function createVoice(cfg = {}, ctx = () => ({}), deps = {}) {
+  const provider = resolveProvider(cfg.provider, deps.hasHex);
+  const inBrowser = provider === 'browser';
+  const speech = inBrowser ? null : (deps.speech ?? SPEECH[provider])(cfg);
+  const named = cfg.decider && cfg.decider !== 'grammar' ? cfg.decider : null;
+  if (named && !DECIDERS[named]) throw new Error(`unknown voice decider ${named}`);
+  const deciders = [grammar, ...(named ? [DECIDERS[named](cfg)] : [])];
+
+  // app: the page's tab. Voice runs only the actions that app handles, so a hold never switches tabs.
+  const canIn = (c, app) => (action) => Object.hasOwn(c.actions ?? {}, action) && (!app || c.actions[action].app === app);
+  const titleModel = cfg.taskTitleModel;
+  const ask = titleModel ? (deps.ask ?? ((text, c) => askClaude(text, titleModel, c.configDir))) : null;
+
+  async function withTitle(command, c) {
+    if (command.action !== 'task.add' || !command.params.subject) return command;
+    const params = await titleTask(command.params.subject, ask && ((text) => ask(text, c)));
+    return { ...command, params };
+  }
+
+  async function decide(text, app) {
+    if (!norm(text)) return { kind: 'none' };
+    const c = ctx();
+    const input = { text, apps: c.apps ?? {}, can: canIn(c, app) };
+    for (const d of deciders) {
+      const command = await d(input);
+      if (command) return command.kind === 'invoke' ? withTitle(command, c) : command;
+    }
+    if (!input.can('session.paste')) return { kind: 'unknown' };
+    return { kind: 'invoke', action: 'session.paste', params: { text: text.trim() } };
+  }
+
+  async function stop(app) {
+    const r = await speech.stop();
+    if (!r.ok) return r;
+    return { ...r, command: await decide(r.text, app) };
+  }
+
+  // Live text while the key is held: {text, newSession, command?}. With newSession, text is the prompt
+  // after "new session", so the page opens the dialog at once and types the rest into it. With
+  // command (its label), text is the rest after the prefix or phrase, which the page shows but never types.
+  // action names the matched row; a row with a live dialog carries the words so far as its params.
+  function live(text, app) {
+    const m = matchCommand(text, canIn(ctx(), app));
+    if (!m) return { text, newSession: false };
+    if (m.action === 'session.new') return { text: m.rest, newSession: true };
+    const r = { text: m.rest, newSession: false, command: m.label };
+    if (!m.action) return r;
+    return { ...r, action: m.action, ...(m.live && { params: { [m.live.param]: m.rest } }) };
+  }
+
+  // The browser provider's text so far, and its final text with the command.
+  async function text(said, final, app) {
+    const t = String(said ?? '').trim();
+    if (!final) return { ok: true, ...live(t, app) };
+    return { ok: true, ...live(t, app), command: await decide(t, app) };
+  }
+
+  const stream = inBrowser ? null : ((deps.stream ?? STREAMS[provider])?.(cfg) ?? null);
+  const streamOps = stream && {
+    start: () => stream.start(),
+    audio: async (buf, app) => {
+      const r = await stream.audio(buf);
+      return r.ok ? { ...r, ...live(r.text, app) } : r;
+    },
+    finish: async (_body, app) => {
+      const r = await stream.finish();
+      return r.ok ? { ...r, ...live(r.text, app), command: await decide(r.text, app) } : r;
+    },
+    cancel: () => stream.cancel(),
+  };
+
+  const base = {
+    provider,
+    auto: (cfg.provider ?? 'auto') === 'auto',
+    commands: commandList(),
+    decide,
+    live,
+    text,
+    stream: streamOps,
+  };
+  if (inBrowser) return { ...base, start: IN_BROWSER, stop: IN_BROWSER, dictate: IN_BROWSER, cancel: IN_BROWSER };
+  return { ...base, start: () => speech.start(), stop, dictate: () => speech.stop(), cancel: () => speech.cancel() };
+}
+
+module.exports = { createVoice };

package/lib/voice/title.js

@@ -0,0 +1,77 @@
+'use strict';
+
+// Turns a spoken task into a title and a description. Short text is the title as said. Longer text
+// stays whole in the description, as said, and gets a title: written by voice.taskTitleModel when
+// it is set and answers, else the words before the first sentence break, else none.
+const { spawn } = require('node:child_process');
+const os = require('node:os');
+
+const MAX_TITLE_WORDS = 8;
+const MAX_MODEL_TITLE_WORDS = 12;
+const ASK_TIMEOUT_MS = 15000;
+const BREAK = /^(.+?)[,.;:!?](?:\s|$)/;
+
+const PROMPT =
+  'You get a spoken task. Write a short title for it, 3 to 8 words, in the language of the task, using its own words where you can. No quotes, no period. Reply with the title only.';
+
+const words = (s) => s.split(/\s+/).filter(Boolean).length;
+
+function cleanTitle(answer) {
+  const title = String(answer ?? '')
+    .trim()
+    .replace(/^["'“”‘’]+|["'“”‘’]+$/g, '')
+    .replace(/[.!]+$/, '')
+    .trim();
+  if (!title || title.includes('\n') || words(title) > MAX_MODEL_TITLE_WORDS) return '';
+  return title;
+}
+
+// `ask(text)` answers a title; an empty, multi-line or long answer is ignored.
+async function titleTask(said, ask) {
+  const text = String(said ?? '').trim();
+  if (words(text) <= MAX_TITLE_WORDS) return { subject: text };
+  const title = ask ? cleanTitle(await ask(text).catch(() => '')) : '';
+  const subject = title || (BREAK.exec(text)?.[1] ?? '');
+  return { subject, description: text };
+}
+
+// One plain answer from the Claude Code CLI: no tools, MCP servers, settings, hooks or skills, the
+// default system prompt replaced, and no transcript, so no session shows on the board. `configDir`
+// is the hub's active one when it is not the default, so the CLI uses that dir's login.
+function askClaude(text, model, configDir) {
+  const env = configDir ? { ...process.env, CLAUDE_CONFIG_DIR: configDir } : process.env;
+  const args = ['-p', '--model', model, '--output-format', 'json', '--tools', '', '--strict-mcp-config'];
+  args.push('--setting-sources', '', '--disable-slash-commands', '--no-session-persistence', '--max-turns', '1');
+  args.push('--system-prompt', PROMPT, text);
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      // stdin closed: the CLI otherwise waits 3 s for piped input.
+      child = spawn('claude', args, { cwd: os.tmpdir(), env, windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] });
+    } catch (err) {
+      return reject(err);
+    }
+    let out = '';
+    const timer = setTimeout(() => child.kill(), ASK_TIMEOUT_MS);
+    child.stdout.on('data', (d) => {
+      out += d;
+    });
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.on('close', () => {
+      clearTimeout(timer);
+      try {
+        const r = JSON.parse(out);
+        // A failed login or API error comes back as text in `result`, flagged by is_error.
+        if (r.is_error) throw new Error(String(r.result ?? 'claude failed'));
+        resolve(String(r.result ?? ''));
+      } catch (err) {
+        reject(err);
+      }
+    });
+  });
+}
+
+module.exports = { titleTask, askClaude };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-hub",
-  "version": "1.26.0",
+  "version": "1.27.1",
   "description": "Unified hub for Claude Code tools — Marketplace + Kanban in one PWA",
   "main": "server.js",
   "bin": {
@@ -46,10 +46,10 @@
   },
   "homepage": "https://github.com/NikiforovAll/claude-code-hub#readme",
   "dependencies": {
-    "claude-code-cost": "1.6.0",
-    "claude-code-kanban": "7.23.0",
-    "claude-code-marketplace": "1.7.1",
-    "claude-code-memory-explorer": "1.3.4",
+    "claude-code-cost": "1.6.1",
+    "claude-code-kanban": "7.24.0",
+    "claude-code-marketplace": "1.7.2",
+    "claude-code-memory-explorer": "1.3.5",
     "express": "^4.21.0",
     "open": "^10.1.0"
   },
@@ -60,6 +60,7 @@
     "server.js",
     "public/**/*",
     "lib/**/*",
+    "features/**/*",
     "plugin/**/*",
     "tray/**/*",
     "packages/claude-hub-sdk/src/**/*"

package/packages/claude-hub-sdk/src/keys.js

@@ -17,7 +17,7 @@ var ClaudeHubKeys = (() => {
   function comboOf(e) {
     const lower = typeof e.key === 'string' ? e.key.toLowerCase() : '';
     const m = !e.getModifierState?.('AltGraph') && /^(?:Key|Digit)([A-Z1-9])$/.exec(e.code || '');
-    const key = /^[a-z1-9]$/.test(lower) ? lower : m ? m[1].toLowerCase() : e.key;
+    const key = /^[a-z1-9]$/.test(lower) ? lower : m ? m[1].toLowerCase() : e.key === ' ' ? 'Space' : e.key;
     const mods = [e.ctrlKey && 'ctrl', e.altKey && 'alt', e.shiftKey && 'shift', e.metaKey && 'meta'];
     return [...mods, key].filter(Boolean).join('+');
   }