scalemax 0.1.25 → 0.1.28

package/README.md

@@ -77,6 +77,7 @@ scalemax logout       Remove stored ScaleMax API key
 scalemax doctor       Run diagnostics
 scalemax models       List available ScaleMax models
 scalemax helper-bot   Open the ScaleMax-only support assistant
+scalemax claude-tools Install bounded GitHub skill tools for Claude
 scalemax update       Reconfigure detected clients with the stored key
 scalemax remove       Remove ScaleMax-generated client configuration
 scalemax --help       Show help
@@ -121,7 +122,10 @@ npx scalemax@latest helper-bot --model fable-5 "Help me configure ScaleMax in Cu
 
 Recognized setup, repair, and verification requests execute the CLI's allowlisted client operations directly. Requests such as `setup all providers`, `fix Hermes request failed`, `configure Claude Code`, `verify OpenCode`, and `setup vs code roo extension for claude` are handled by the controller before any model request. The controller detects the relevant client, runs a safe installer when the client has one, verifies existing ScaleMax configuration, repairs ScaleMax-managed files when verification fails, re-verifies, and reports each step.
 
-For Roo Code, helper-bot can install VS Code on Windows with the fixed Microsoft winget package, install the official Roo Code extension, write OpenAI and Claude ScaleMax profiles when the key exposes both families, and verify the import handoff. For general troubleshooting that cannot be completed by a fixed client action, helper-bot sends a small `gpt-5.4` request grounded with bundled ScaleMax documentation about stored authentication, credit/token base URLs, provider scope, client setup, and common errors. The language model never generates or executes shell commands; only fixed ScaleMax client detection, installation, configuration, verification, and rollback operations are available to the controller.
+For Claude tool access, run `scalemax claude-tools`, or ask helper-bot to `install GitHub skill tools for Claude Desktop and Claude Code`. Claude Code receives Anthropic's official `example-skills@anthropic-agent-skills` plugin plus public-GitHub read permissions. Claude Desktop/Cowork receives a local MCP server with only three tools: `github_fetch`, `github_tree`, and `github_install_skill`. The MCP server accepts only public GitHub HTTPS hosts, limits downloads, rejects unsafe archive paths and symlinks, refuses to replace an existing skill, and can write only beneath `~/Claude/skills`. It does not expose a general shell, arbitrary URLs, or unrestricted filesystem access. Restart Claude Desktop after installation and use Cowork or Code; a normal Chat tab does not expose local tools.
+Only install skills from repositories you trust: a `SKILL.md` is instruction content that Claude may follow after installation, even though the bridge itself cannot execute arbitrary repository code.
+
+For Roo Code, helper-bot can install VS Code on Windows with the fixed Microsoft winget package, install the official Roo Code extension, write OpenAI and Claude ScaleMax profiles when the key exposes those families, and verify the import handoff. For DeepSeek V4 Flash, helper-bot installs and configures Continue's Chat/Edit integration instead because the Azure deployment has no tool calling. For general troubleshooting that cannot be completed by a fixed client action, helper-bot sends a small `gpt-5.4` request grounded with bundled ScaleMax documentation about stored authentication, credit/token base URLs, provider scope, client setup, and common errors. The language model never generates or executes shell commands; only fixed ScaleMax client detection, installation, configuration, verification, and rollback operations are available to the controller.
 
 The helper refuses unrelated requests and redacts ScaleMax-style secrets from prompts, provider output, errors, and progress notifications. Use `/status` for non-secret connection details, `/help` for commands, and `/quit` to exit.
 
@@ -132,6 +136,7 @@ The helper refuses unrelated requests and redacts ScaleMax-style secrets from pr
 - Codex
 - Cursor
 - Roo Code (VS Code)
+- Continue (VS Code)
 - TRAE SOLO
 - Claude Code
 - OpenCode
@@ -156,7 +161,7 @@ ScaleMax merges a named `scalemax` provider into `~/.config/opencode/opencode.js
 
 ### OpenClaw
 
-ScaleMax partitions OpenClaw models into native `openai-responses` (`scalemax-codex`, `/v1`) and `anthropic-messages` (`scalemax-claude`, origin) providers. The API key and compatibility User-Agent are OpenClaw file-backed SecretRefs stored in private `0600` files under `~/.openclaw/secrets/`; neither value is embedded in the main provider JSON. Migration removes the obsolete mixed provider, preserves the active model family, and scrubs plaintext credentials from generated ScaleMax agent registries even when they contain an older key. Output is capped at 4096 tokens, private-network routing is denied for the public gateway, and unrelated providers and agent settings are preserved.
+ScaleMax partitions OpenClaw models into native `openai-responses` (`scalemax-codex`, `/v1`), OpenAI-compatible `openai-completions` (`scalemax-deepseek`, `/v1`), and `anthropic-messages` (`scalemax-claude`, origin) providers. `deepseek-v4-flash` is isolated in the Chat Completions provider with tools disabled; it is never advertised through Responses. The API key and compatibility User-Agent are OpenClaw file-backed SecretRefs stored in private `0600` files under `~/.openclaw/secrets/`; neither value is embedded in the main provider JSON. Migration removes the obsolete mixed provider, preserves the active model family, and scrubs plaintext credentials from generated ScaleMax agent registries even when they contain an older key. Output is capped at 4096 tokens, private-network routing is denied for the public gateway, and unrelated providers and agent settings are preserved.
 
 ### Hermes
 
@@ -164,7 +169,11 @@ ScaleMax creates family-specific Hermes providers in `~/.hermes/config.yaml` and
 
 ### Roo Code (VS Code)
 
-Roo Code stores provider profiles and secrets in VS Code extension storage, so ScaleMax does not mutate its private database. Instead, the CLI writes a private `0600` Roo settings-import file at `~/.scalemax/roo-code-import.json` and points the supported `roo-cline.autoImportSettingsPath` VS Code setting at it. Reload VS Code once so Roo imports the Codex/OpenAI-only profile into its SecretStorage. CLI verification intentionally reports the handoff as verified, not the extension runtime, until that reload occurs.
+Roo Code stores provider profiles and secrets in VS Code extension storage, so ScaleMax does not mutate its private database. Instead, the CLI writes a private `0600` Roo settings-import file at `~/.scalemax/roo-code-import.json` and points the supported `roo-cline.autoImportSettingsPath` VS Code setting at it. Codex and Claude profiles remain separate. DeepSeek V4 Flash is deliberately not offered in Roo because Roo's task-completion loop requires tool calling and this Azure deployment does not expose it. Reload VS Code once so Roo imports supported profiles into its SecretStorage. CLI verification intentionally reports the handoff as verified, not the extension runtime, until that reload occurs.
+
+### Continue (VS Code)
+
+Continue is the supported VS Code route for `deepseek-v4-flash`. The CLI installs the official `Continue.continue` extension when VS Code is available, merges a Chat/Edit-only OpenAI-compatible model into `~/.continue/config.yaml`, sets `useResponsesApi: false`, and keeps the authenticated ScaleMax key in private `~/.continue/.env` rather than the YAML. Existing Continue models and environment entries are preserved. Reload VS Code, select **ScaleMax DeepSeek V4 Flash**, and use Chat or Edit; Agent mode is unavailable because the deployment does not expose tool calling.
 
 ### Cursor BYOK routing on macOS
 

package/dist/assets/claude-github-tools.mjs

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+
+/**
+ * Least-privilege GitHub MCP bridge installed by ScaleMax for Claude Desktop.
+ *
+ * It exposes no general shell, arbitrary URL, or general filesystem tool. It
+ * can read public GitHub content and install one repository subdirectory that
+ * contains SKILL.md under ~/Claude/skills. Existing skills are never replaced.
+ */
+import { createInterface } from 'node:readline';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+const MAX_FETCH_BYTES = 512 * 1024;
+const MAX_TREE_BYTES = 2 * 1024 * 1024;
+const MAX_ARCHIVE_BYTES = 32 * 1024 * 1024;
+const MAX_INSTALLED_BYTES = 64 * 1024 * 1024;
+const MAX_INSTALLED_FILES = 2_000;
+const ALLOWED_HOSTS = new Set([
+  'github.com',
+  'raw.githubusercontent.com',
+  'api.github.com',
+  'codeload.github.com',
+  'objects.githubusercontent.com',
+]);
+const SKILLS_ROOT = path.join(os.homedir(), 'Claude', 'skills');
+
+function send(message) {
+  process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+
+function result(id, value) {
+  send({ jsonrpc: '2.0', id, result: value });
+}
+
+function failure(id, code, message) {
+  send({ jsonrpc: '2.0', id, error: { code, message } });
+}
+
+function isSafeRelative(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= 500 &&
+    !path.posix.isAbsolute(value) && !value.split('/').includes('..') &&
+    !value.split('/').some(part => !part || part === '.') &&
+    !value.includes('\\') && !value.includes('\0');
+}
+
+function validateHost(rawUrl) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    throw new Error('url must be a valid HTTPS URL');
+  }
+  if (url.protocol !== 'https:' || !ALLOWED_HOSTS.has(url.hostname.toLowerCase())) {
+    throw new Error('only public GitHub HTTPS hosts are allowed');
+  }
+  if (url.username || url.password) throw new Error('credentialed URLs are not allowed');
+  for (const key of url.searchParams.keys()) {
+    if (/(?:token|key|secret|signature|credential|auth)/i.test(key)) {
+      throw new Error('credential-like URL query parameters are not allowed');
+    }
+  }
+  return url;
+}
+
+async function readLimited(response, limit = MAX_FETCH_BYTES) {
+  const length = Number(response.headers.get('content-length') || 0);
+  if (length > limit) throw new Error(`response exceeds ${limit} bytes`);
+  const reader = response.body?.getReader();
+  if (!reader) {
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.byteLength > limit) throw new Error(`response exceeds ${limit} bytes`);
+    return bytes;
+  }
+  const chunks = [];
+  let total = 0;
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > limit) {
+      await reader.cancel();
+      throw new Error(`response exceeds ${limit} bytes`);
+    }
+    chunks.push(Buffer.from(value));
+  }
+  return Buffer.concat(chunks);
+}
+
+async function fetchBytes(rawUrl, limit = MAX_FETCH_BYTES) {
+  const url = validateHost(rawUrl);
+  const response = await fetch(url, {
+    method: 'GET',
+    redirect: 'error',
+    headers: { 'user-agent': 'ScaleMax-Claude-GitHub-Tools/1.1' },
+  });
+  if (!response.ok) throw new Error(`GitHub returned HTTP ${response.status}`);
+  return { url: url.toString(), response, bytes: await readLimited(response, limit) };
+}
+
+function repoSlug(repo) {
+  if (typeof repo !== 'string' || !/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repo)) {
+    throw new Error('repo must be in owner/name form');
+  }
+  return repo;
+}
+
+function safeRef(ref = 'main') {
+  if (typeof ref !== 'string' || !/^[A-Za-z0-9._/-]{1,120}$/.test(ref) || ref.includes('..')) {
+    throw new Error('ref contains unsupported characters');
+  }
+  return ref;
+}
+
+async function githubFetch(args) {
+  const maxBytes = Number.isInteger(args?.max_bytes)
+    ? Math.min(Math.max(args.max_bytes, 1), MAX_FETCH_BYTES)
+    : MAX_FETCH_BYTES;
+  const { url, response, bytes } = await fetchBytes(args?.url, maxBytes);
+  const contentType = response.headers.get('content-type') || 'application/octet-stream';
+  const text = /(?:text|json|javascript|xml|yaml)/i.test(contentType)
+    ? bytes.toString('utf8')
+    : `[binary response: ${bytes.byteLength} bytes, ${contentType}]`;
+  return { url, status: response.status, content_type: contentType, bytes: bytes.byteLength, content: text };
+}
+
+async function githubTree(args) {
+  const repo = repoSlug(args?.repo);
+  const ref = safeRef(args?.ref);
+  const encodedRef = ref.split('/').map(encodeURIComponent).join('/');
+  const { bytes } = await fetchBytes(`https://api.github.com/repos/${repo}/git/trees/${encodedRef}?recursive=1`, MAX_TREE_BYTES);
+  const payload = JSON.parse(bytes.toString('utf8'));
+  if (!Array.isArray(payload.tree)) throw new Error('GitHub did not return a repository tree');
+  return {
+    repo,
+    ref,
+    truncated: payload.truncated === true,
+    paths: payload.tree.filter(entry => entry.type === 'blob').map(entry => entry.path).slice(0, 5_000),
+  };
+}
+
+function archiveRoot(entries) {
+  const roots = new Set();
+  for (const entry of entries) {
+    const normalized = entry.replace(/^\.?\//, '');
+    if (normalized.startsWith('/') || normalized.split('/').includes('..') || normalized.includes('\\')) {
+      throw new Error('unsafe archive path rejected');
+    }
+    const root = normalized.split('/')[0];
+    if (!root) throw new Error('invalid archive entry');
+    roots.add(root);
+  }
+  if (roots.size !== 1) throw new Error('unexpected archive layout');
+  return [...roots][0];
+}
+
+async function validateExtractedTree(root) {
+  const pending = [root];
+  let files = 0;
+  let bytes = 0;
+  while (pending.length) {
+    const current = pending.pop();
+    const stat = await fs.lstat(current);
+    if (stat.isSymbolicLink()) throw new Error('skill archives may not contain symbolic links');
+    if (stat.isDirectory()) {
+      for (const name of await fs.readdir(current)) pending.push(path.join(current, name));
+      continue;
+    }
+    if (!stat.isFile()) throw new Error('skill archives may contain only files and directories');
+    files += 1;
+    bytes += stat.size;
+    if (files > MAX_INSTALLED_FILES || bytes > MAX_INSTALLED_BYTES) throw new Error('extracted skill exceeds safety limits');
+  }
+}
+
+async function tarCommand() {
+  const candidates = process.platform === 'win32'
+    ? [path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'tar.exe')]
+    : ['/usr/bin/tar', '/bin/tar'];
+  for (const candidate of candidates) {
+    try { await fs.access(candidate); return candidate; } catch {}
+  }
+  throw new Error('a system tar utility is required to install a GitHub skill');
+}
+
+async function safeSkillsRoot() {
+  await fs.mkdir(SKILLS_ROOT, { recursive: true, mode: 0o700 });
+  const resolved = await fs.realpath(SKILLS_ROOT);
+  const expected = path.resolve(SKILLS_ROOT);
+  const samePath = process.platform === 'win32'
+    ? resolved.toLowerCase() === expected.toLowerCase()
+    : resolved === expected;
+  if (!samePath) throw new Error('refusing a symlinked Claude skills directory');
+  return resolved;
+}
+
+async function githubInstallSkill(args) {
+  const repo = repoSlug(args?.repo);
+  const ref = safeRef(args?.ref);
+  const skillPath = args?.skill_path || '';
+  if (!isSafeRelative(skillPath)) throw new Error('skill_path must be a non-empty safe relative path');
+  const skillName = path.posix.basename(skillPath);
+  if (!/^[A-Za-z0-9._-]{1,80}$/.test(skillName)) throw new Error('skill directory name is not safe');
+  const skillsRoot = await safeSkillsRoot();
+  const destination = path.join(skillsRoot, skillName);
+  try {
+    await fs.access(destination);
+    throw new Error(`skill already exists at ${destination}; refusing to overwrite`);
+  } catch (error) {
+    if (error?.message?.startsWith('skill already exists')) throw error;
+    if (error?.code !== 'ENOENT') throw error;
+  }
+
+  const encodedRef = ref.split('/').map(encodeURIComponent).join('/');
+  const { bytes } = await fetchBytes(`https://codeload.github.com/${repo}/tar.gz/${encodedRef}`, MAX_ARCHIVE_BYTES);
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'scalemax-skill-'));
+  const archive = path.join(tempRoot, 'repo.tar.gz');
+  const extracted = path.join(tempRoot, 'extracted');
+  try {
+    await fs.writeFile(archive, bytes, { mode: 0o600 });
+    await fs.mkdir(extracted, { mode: 0o700 });
+    const tar = await tarCommand();
+    const verbose = await execFileAsync(tar, ['-tvzf', archive], { maxBuffer: 4 * 1024 * 1024 });
+    for (const line of String(verbose.stdout).split('\n')) {
+      const marker = line.trimStart()[0];
+      if (marker === 'l' || marker === 'h') throw new Error('skill archives may not contain symbolic or hard links');
+    }
+    const listing = await execFileAsync(tar, ['-tzf', archive], { maxBuffer: 4 * 1024 * 1024 });
+    const entries = String(listing.stdout).split('\n').map(value => value.trim()).filter(Boolean);
+    const root = archiveRoot(entries);
+    const normalizedSkillPath = skillPath.replace(/^\/+|\/+$/g, '');
+    const prefix = `${root}/${normalizedSkillPath}`;
+    if (!entries.some(entry => entry.replace(/\/$/, '') === `${prefix}/SKILL.md`)) {
+      throw new Error('requested repository path does not contain SKILL.md');
+    }
+    await execFileAsync(tar, ['-xzf', archive, '-C', extracted, prefix], { maxBuffer: 4 * 1024 * 1024 });
+    const source = path.join(extracted, root, ...normalizedSkillPath.split('/'));
+    await validateExtractedTree(source);
+    const skillFile = path.join(source, 'SKILL.md');
+    if (!(await fs.lstat(skillFile)).isFile()) throw new Error('SKILL.md is not a regular file');
+    try { await fs.rename(source, destination); }
+    catch (error) {
+      if (error?.code !== 'EXDEV') throw error;
+      await fs.cp(source, destination, { recursive: true, force: false, errorOnExist: true });
+      await fs.rm(source, { recursive: true, force: true });
+    }
+    return { repo, ref, skill_path: skillPath, installed_to: destination };
+  } finally {
+    await fs.rm(tempRoot, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+const tools = [
+  {
+    name: 'github_fetch',
+    description: 'Read public GitHub text or metadata over HTTPS. Only GitHub hosts are permitted; no writes or arbitrary URLs.',
+    inputSchema: { type: 'object', properties: { url: { type: 'string' }, max_bytes: { type: 'integer', minimum: 1, maximum: MAX_FETCH_BYTES } }, required: ['url'] },
+    annotations: { readOnlyHint: true, openWorldHint: false },
+  },
+  {
+    name: 'github_tree',
+    description: 'List public files in a GitHub repository/ref so a skill directory can be selected.',
+    inputSchema: { type: 'object', properties: { repo: { type: 'string' }, ref: { type: 'string' } }, required: ['repo'] },
+    annotations: { readOnlyHint: true, openWorldHint: false },
+  },
+  {
+    name: 'github_install_skill',
+    description: 'Download one public GitHub skill directory containing SKILL.md into ~/Claude/skills. Refuses overwrite and unsafe paths.',
+    inputSchema: { type: 'object', properties: { repo: { type: 'string' }, skill_path: { type: 'string' }, ref: { type: 'string' } }, required: ['repo', 'skill_path'] },
+    annotations: { readOnlyHint: false, openWorldHint: false },
+  },
+];
+
+async function handle(request) {
+  const id = request.id;
+  switch (request.method) {
+    case 'initialize':
+      return result(id, {
+        protocolVersion: request.params?.protocolVersion || '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'scalemax-github-tools', version: '1.1.0' },
+      });
+    case 'notifications/initialized':
+    case 'notifications/cancelled':
+      return;
+    case 'ping':
+      return result(id, {});
+    case 'tools/list':
+      return result(id, { tools });
+    case 'tools/call': {
+      try {
+        const name = request.params?.name;
+        const args = request.params?.arguments || {};
+        let value;
+        if (name === 'github_fetch') value = await githubFetch(args);
+        else if (name === 'github_tree') value = await githubTree(args);
+        else if (name === 'github_install_skill') value = await githubInstallSkill(args);
+        else throw new Error(`unknown tool: ${name}`);
+        return result(id, { content: [{ type: 'text', text: JSON.stringify(value, null, 2) }], structuredContent: value });
+      } catch (error) {
+        return result(id, { content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }], isError: true });
+      }
+    }
+    default:
+      return failure(id, -32601, `method not found: ${request.method}`);
+  }
+}
+
+const input = createInterface({ input: process.stdin, crlfDelay: Infinity });
+input.on('line', line => {
+  if (!line.trim()) return;
+  let request;
+  try { request = JSON.parse(line); } catch { return; }
+  Promise.resolve(handle(request)).catch(error => failure(request.id, -32603, error instanceof Error ? error.message : String(error)));
+});

package/dist/clients.js

@@ -4,6 +4,8 @@ import * as cursorDetect from './detect/cursor.js';
 import * as cursorConfig from './configure/cursor.js';
 import * as rooCodeDetect from './detect/roo-code.js';
 import * as rooCodeConfig from './configure/roo-code.js';
+import * as continueDetect from './detect/continue.js';
+import * as continueConfig from './configure/continue.js';
 import * as traeSoloDetect from './detect/trae-solo.js';
 import * as traeSoloConfig from './configure/trae-solo.js';
 import * as claudeDetect from './detect/claude.js';
@@ -22,6 +24,7 @@ export const clients = [
     { id: 'codex', name: 'Codex', detect: codexDetect.detect, install: codexConfig.install, configure: codexConfig.configure, verify: codexConfig.verify, launch: codexConfig.launch, remove: codexConfig.remove },
     { id: 'cursor', name: 'Cursor', detect: cursorDetect.detect, configure: cursorConfig.configure, verify: cursorConfig.verify, remove: cursorConfig.remove },
     { id: 'roo-code', name: 'Roo Code (VS Code)', detect: rooCodeDetect.detect, configure: rooCodeConfig.configure, verify: rooCodeConfig.verify, remove: rooCodeConfig.remove },
+    { id: 'continue', name: 'Continue (VS Code)', detect: continueDetect.detect, install: continueConfig.install, configure: continueConfig.configure, verify: continueConfig.verify, remove: continueConfig.remove },
     { id: 'trae-solo', name: 'TRAE SOLO', detect: traeSoloDetect.detect, configure: traeSoloConfig.configure, remove: traeSoloConfig.remove },
     { id: 'claude', name: 'Claude Code', detect: claudeDetect.detect, configure: claudeConfig.configure, verify: claudeConfig.verify, remove: claudeConfig.remove },
     { id: 'opencode', name: 'OpenCode', detect: opencodeDetect.detect, configure: opencodeConfig.configure, verify: opencodeConfig.verify, remove: opencodeConfig.remove },

package/dist/commands/claude-tools.d.ts

@@ -0,0 +1 @@
+export declare function claudeToolsCommand(home?: string): Promise<void>;

package/dist/commands/claude-tools.js

@@ -0,0 +1,16 @@
+import chalk from 'chalk';
+import { installClaudeGithubTools } from '../configure/claude-tools.js';
+import { homeDir } from '../utils/paths.js';
+export async function claudeToolsCommand(home = homeDir()) {
+    console.log(chalk.dim('Installing bounded public-GitHub tools for Claude Desktop/Cowork and Claude Code…'));
+    const result = await installClaudeGithubTools('both', home, process.platform, process.env);
+    if (result.desktop) {
+        console.log(chalk.green(`✓ Claude Desktop MCP verified (${result.desktop.configPaths.length} config${result.desktop.configPaths.length === 1 ? '' : 's'}).`));
+        console.log(chalk.dim(`  Tools: github_fetch, github_tree, github_install_skill · destination: ~/Claude/skills`));
+    }
+    if (result.code?.installed)
+        console.log(chalk.green(`✓ Claude Code ${result.code.message}.`));
+    else if (result.code)
+        console.log(chalk.yellow(`! ${result.code.message}`));
+    console.log(chalk.dim('No general shell, arbitrary URL, or unrestricted filesystem tool was granted. Restart Claude Desktop before using the new MCP tools.'));
+}

package/dist/commands/configure.js

@@ -6,6 +6,7 @@ import { SCALEMAX_BASE_URL } from '../constants.js';
 import { loadApiKey } from '../utils/keyStore.js';
 import { validateApiKey, isAnthropicModel } from '../utils/api.js';
 import { homeDir } from '../utils/paths.js';
+import { isDeepSeekChatModelId } from '../configure/models.js';
 export async function detectAll(home = homeDir()) {
     const ctx = { home, platform: process.platform, env: process.env };
     return Promise.all(clients.map(c => c.detect(ctx)));
@@ -44,13 +45,26 @@ export function clientAllowedForModels(clientId, models) {
         return false;
     // These clients use either a native family-specific adapter or the gateway's
     // normalized OpenAI-compatible Chat Completions route, which supports both
-    // authenticated model families. Codex and TRAE remain OpenAI-only.
-    const crossProtocolClients = new Set(['claude', 'cursor', 'roo-code', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
+    // authenticated model families. Codex remains Responses-only; TRAE uses
+    // OpenAI-compatible Chat Completions.
+    const crossProtocolClients = new Set(['cursor', 'roo-code', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
+    if (clientId === 'continue')
+        return models.some(model => isDeepSeekChatModelId(model.id));
+    if (clientId === 'claude')
+        return models.some(isAnthropicModel);
+    if (clientId === 'codex')
+        return models.some(model => !isAnthropicModel(model) && !isDeepSeekChatModelId(model.id));
+    if (clientId === 'hermes' && models.every(model => isDeepSeekChatModelId(model.id)))
+        return false;
+    if (clientId === 'roo-code' && models.every(model => isDeepSeekChatModelId(model.id)))
+        return false;
     if (crossProtocolClients.has(clientId))
         return true;
     return models.some(model => !isAnthropicModel(model));
 }
 function scopeHint(scope) {
+    if (scope === 'deepseek-v4-flash')
+        return 'DeepSeek V4 Flash only';
     return scope === 'both' ? 'OpenAI + Claude' : scope === 'anthropic' ? 'Claude only' : 'OpenAI only';
 }
 export async function configureCommand(opts = {}) {

package/dist/commands/helper-bot.d.ts

@@ -1,7 +1,7 @@
 import { type ChatCompletionOptions, type ChatCompletionResult, type ChatMessage, type ModelInfo } from '../utils/api.js';
 import { loadApiKey } from '../utils/keyStore.js';
 import { validateApiKey } from '../utils/api.js';
-import type { ClientDefinition } from '../types/client.js';
+import type { ClientDefinition, ProviderScope } from '../types/client.js';
 export declare const SCALEMAX_HELPER_REFUSAL: string;
 export declare const SCALEMAX_HELPER_SYSTEM_PROMPT: string;
 export declare const SCALEMAX_HELPER_INVALID_PROVIDER_RESPONSE: string;
@@ -14,7 +14,7 @@ export interface HelperConnection {
     baseUrl: string;
     model: string;
     platform?: NodeJS.Platform;
-    providerScope?: 'openai' | 'anthropic' | 'both';
+    providerScope?: ProviderScope;
     keyMode?: string;
     availableModels?: string[];
     modelCatalog?: ModelInfo[];

package/dist/commands/helper-bot.js

@@ -10,6 +10,7 @@ import { loadApiKey } from '../utils/keyStore.js';
 import { homeDir } from '../utils/paths.js';
 import { validateApiKey } from '../utils/api.js';
 import { commandExists } from '../utils/exec.js';
+import { installClaudeGithubTools } from '../configure/claude-tools.js';
 export const SCALEMAX_HELPER_REFUSAL = `I am the official ScaleMax Helper.
 
 I can only assist with installing, configuring, repairing, verifying, and troubleshooting ScaleMax.
@@ -542,6 +543,7 @@ const SCALEMAX_TOPIC_PATTERN = /\b(?:scalemax|api\s*key|stored\s+key|customer\s+
 const TROUBLESHOOTING_PATTERN = /\b(?:error|failed?|failure|broken|not\s+working|doesn['’]?t\s+work|cannot|can['’]?t|timeout|invalid|unauthorized|forbidden|help)\b/i;
 const GREETING_PATTERN = /^(?:hi|hello|hey|help|what can you do)[!.?\s]*$/i;
 const CLAUDE_DESKTOP_PATTERN = /\bclaude\s+desktop\b/i;
+const CLAUDE_GITHUB_TOOLS_PATTERN = /\b(?:github|skills?|mcp|tools?|download)\b/i;
 const CLAUDE_DESKTOP_CONFIGURATION_PATTERN = /\b(?:configur(?:e|ation)|setup|set\s*up|gateway|base\s*url|api\s*key|connect(?:ion)?|third[- ]party|inference|field|install|verify)\b/i;
 const CODEX_CLI_PATTERN = /\bcodex(?:\s+cli)?\b/i;
 const CLIENT_CONFIGURATION_PATTERN = /\b(?:configur(?:e|ation)|setup|set\s*up|base\s*url|api\s*key|connect(?:ion)?|provider|install|repair|verify|update)\b/i;
@@ -758,7 +760,8 @@ For automatic configuration, exit with \`/quit\`, run \`scalemax update\`, then
     return reply;
 }
 const HELPER_CLIENT_PATTERNS = [
-    { id: 'roo-code', pattern: /\b(?:roo(?:\s+code)?|roo\s+(?:extension|plugin)|vscode\s+roo|vs\s+code\s+roo|vs\s*code\s+extension|visual\s+studio\s+code\s+extension)\b/i },
+    { id: 'continue', pattern: /\b(?:continue(?:\.dev)?|vscode\s+continue|vs\s+code\s+continue)\b/i },
+    { id: 'roo-code', pattern: /\b(?:roo(?:\s+code)?|roo\s+(?:extension|plugin)|vscode\s+roo|vs\s+code\s+roo)\b/i },
     { id: 'openclaw', pattern: /\bopen\s*claw\b/i },
     { id: 'opencode', pattern: /\bopen\s*code\b/i },
     { id: 'cherry-studio', pattern: /\bcherry\s*studio\b/i },
@@ -770,6 +773,10 @@ const HELPER_CLIENT_PATTERNS = [
     { id: 'claude', pattern: /\bclaude(?:\s+code|\s+cli)?\b/i }
 ];
 function helperActionKind(question) {
+    if (CLAUDE_GITHUB_TOOLS_PATTERN.test(question) && /\b(?:cannot|can['’]?t|unable|not\s+(?:able|being\s+able)|doesn['’]?t\s+have|no\s+tools?)\b/i.test(question))
+        return 'repair';
+    if (CLAUDE_GITHUB_TOOLS_PATTERN.test(question) && /\b(?:enable|grant|provide|add)\b/i.test(question))
+        return 'configure';
     if (/\b(?:repair|fix|troubleshoot|diagnose|not\s+working|doesn['’]?t\s+work|broken|failed?|invalid|timeout|rate\s*limit(?:ed)?)\b/i.test(question))
         return 'repair';
     if (HELPER_MUTATION_PATTERN.test(question))
@@ -779,6 +786,8 @@ function helperActionKind(question) {
     return undefined;
 }
 function helperActionTarget(question) {
+    if (/\bclaude\b/i.test(question) && CLAUDE_GITHUB_TOOLS_PATTERN.test(question))
+        return 'claude-tools';
     if (CLAUDE_DESKTOP_PATTERN.test(question))
         return undefined;
     if (ALL_CLIENTS_PATTERN.test(question) || /\b(?:all|every)\b.{0,30}\bproviders?\b/i.test(question))
@@ -791,6 +800,8 @@ function helperActionTarget(question) {
     return undefined;
 }
 function requestedProviderScope(question, target) {
+    if (/\bdeepseek(?:[-\s]+v4[-\s]+flash)?\b/i.test(question))
+        return 'deepseek-v4-flash';
     if (/\b(?:both|openai\s*\+\s*claude|claude\s*\+\s*openai)\b/i.test(question))
         return 'both';
     if (/\b(?:claude|anthropic)\b/i.test(question))
@@ -803,17 +814,32 @@ function actionModels(connection, requestedScope) {
     const catalog = connection.modelCatalog?.length
         ? connection.modelCatalog
         : (connection.availableModels || []).map(id => ({ id }));
-    if (!requestedScope || requestedScope === 'both')
+    if (!requestedScope)
         return catalog;
-    return catalog.filter(model => requestedScope === 'anthropic' ? isAnthropicModel(model) : !isAnthropicModel(model));
+    if (requestedScope === 'deepseek-v4-flash') {
+        return catalog.filter(model => model.id.trim().toLowerCase() === 'deepseek-v4-flash');
+    }
+    if (requestedScope === 'both') {
+        return catalog.filter(model => model.id.trim().toLowerCase() !== 'deepseek-v4-flash');
+    }
+    return catalog.filter(model => requestedScope === 'anthropic'
+        ? isAnthropicModel(model)
+        : !isAnthropicModel(model) && model.id.trim().toLowerCase() !== 'deepseek-v4-flash');
 }
 function helperClientAllowedForModels(clientId, models) {
     if (!models.length)
         return false;
-    const crossProtocolClients = new Set(['claude', 'cursor', 'roo-code', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
+    const crossProtocolClients = new Set(['cursor', 'roo-code', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
+    const onlyDeepSeek = models.every(model => model.id.trim().toLowerCase() === 'deepseek-v4-flash');
+    if (clientId === 'continue')
+        return onlyDeepSeek;
+    if (clientId === 'claude')
+        return models.some(isAnthropicModel);
+    if ((clientId === 'codex' || clientId === 'hermes' || clientId === 'roo-code') && onlyDeepSeek)
+        return false;
     if (crossProtocolClients.has(clientId))
         return true;
-    return models.some(model => !isAnthropicModel(model));
+    return models.some(model => !isAnthropicModel(model) && model.id.trim().toLowerCase() !== 'deepseek-v4-flash');
 }
 function hasRooCodeExtension(paths) {
     return paths.some(candidate => /^rooveterinaryinc\.roo-cline-/i.test(path.basename(candidate)));
@@ -897,9 +923,9 @@ async function installRooCodeExtension(ctx, client, write) {
 async function runOneHelperClientAction(kind, client, connection, home, requestedScope, write) {
     const models = actionModels(connection, requestedScope);
     if (!models.length)
-        throw new Error(`The authenticated key does not expose ${requestedScope === 'anthropic' ? 'Claude' : requestedScope === 'openai' ? 'OpenAI' : 'compatible'} models for ${client.name}. No configuration was changed.`);
-    if (client.id === 'codex' && models.every(isAnthropicModel))
-        throw new Error('Codex requires an OpenAI-compatible model, but this key exposes only Claude models. No configuration was changed.');
+        throw new Error(`The authenticated key does not expose ${requestedScope === 'anthropic' ? 'Claude' : requestedScope === 'openai' ? 'OpenAI' : requestedScope === 'deepseek-v4-flash' ? 'DeepSeek V4 Flash' : 'compatible'} models for ${client.name}. No configuration was changed.`);
+    if (client.id === 'codex' && models.every(model => isAnthropicModel(model) || model.id.trim().toLowerCase() === 'deepseek-v4-flash'))
+        throw new Error('Codex requires a Responses-capable model, but this key exposes only Claude or Chat-Completions-only models. No configuration was changed.');
     if (client.id === 'cursor' && connection.platform !== 'darwin')
         throw new Error(`Automatic Cursor configuration is currently verified on macOS only. ${helperPlatformName(connection.platform)} was not modified.`);
     const ctx = {
@@ -970,7 +996,9 @@ async function runOneHelperClientAction(kind, client, connection, home, requeste
             throw new Error(`${client.name} configuration was written but could not be detected afterward.`);
         write(`✓ ${client.name} configuration detected after write.`);
     }
-    const activation = client.id === 'roo-code' ? ' Reload VS Code once so Roo Code imports the verified ScaleMax profile.' : '';
+    const activation = client.id === 'roo-code'
+        ? ' Reload VS Code once so Roo Code imports the verified ScaleMax profile.'
+        : client.id === 'continue' ? ' Reload VS Code once so Continue loads the verified ScaleMax profile.' : '';
     return `✅ Successfully completed: ${client.name} is configured and locally verified.${activation}`;
 }
 /** Execute only narrowly allowlisted ScaleMax client actions; never model-generated shell commands. */
@@ -982,6 +1010,29 @@ export async function executeHelperAction(question, connection, home, clientCata
     const target = helperActionTarget(cleanQuestion);
     if (!kind || !target)
         return undefined;
+    if (target === 'claude-tools') {
+        const toolTarget = CLAUDE_DESKTOP_PATTERN.test(cleanQuestion)
+            ? 'desktop'
+            : /\bclaude\s+(?:code|cli|terminal)\b/i.test(cleanQuestion) ? 'code' : 'both';
+        write(`✓ Stored ${helperBillingMode(connection)} key is authenticated; secrets remain hidden.`);
+        write(`→ ${kind === 'verify' ? 'Verifying and reconciling' : 'Installing'} bounded public-GitHub tools for ${toolTarget === 'both' ? 'Claude Desktop/Cowork and Claude Code' : toolTarget === 'desktop' ? 'Claude Desktop/Cowork' : 'Claude Code'}…`);
+        const tools = await installClaudeGithubTools(toolTarget, home, connection.platform || process.platform, process.env);
+        const completed = [];
+        if (tools.desktop) {
+            completed.push(`Claude Desktop MCP exposes github_fetch, github_tree, and github_install_skill; installs are confined to ~/Claude/skills`);
+            write('✓ Claude Desktop GitHub MCP process and tool catalog verified.');
+        }
+        if (tools.code?.installed) {
+            completed.push(`Claude Code ${tools.code.message}`);
+            write(`✓ Claude Code ${tools.code.message}.`);
+        }
+        else if (tools.code) {
+            write(`! ${tools.code.message}`);
+        }
+        if (!completed.length)
+            throw new Error('Claude Desktop and Claude Code were not detected, so no GitHub tools were installed.');
+        return `✅ Successfully completed: ${completed.join('; ')}. Restart Claude Desktop before using the new MCP tools. No unrestricted shell or filesystem access was granted.`;
+    }
     const scope = requestedProviderScope(cleanQuestion, target);
     const scopedModels = actionModels(connection, scope);
     const selected = target === 'all'