@semalt-ai/code 1.5.0 → 1.7.0

package/README.md

@@ -49,7 +49,7 @@ semalt-code
 Create the CLI config:
 
 ```bash
-semalt-code init --api-base http://127.0.0.1:8800 --api-key any --default-model default
+semalt-code init --api-base http://127.0.0.1:8800 --api-key any --dashboard-url https://cli.semalt.ai --default-model default
 ```
 
 This writes configuration to:
@@ -64,6 +64,8 @@ Example config:
 {
   "api_base": "http://127.0.0.1:8800",
   "api_key": "any",
+  "dashboard_url": "https://cli.semalt.ai",
+  "auth_token": "",
   "default_model": "default",
   "temperature": 0.7,
   "request_timeout_ms": 900000,
@@ -94,8 +96,17 @@ semalt-code [command] [options]
 - `semalt-code shell <command>`
   Runs a shell command with approval prompts.
 
+- `semalt-code login`
+  Starts browser-based login and stores the confirmed CLI token in `~/.semalt-ai/config.json`.
+
+- `semalt-code whoami`
+  Shows the current user associated with the saved CLI auth token.
+
+- `semalt-code logout`
+  Logs out the current CLI user and clears the saved local auth token.
+
 - `semalt-code models`
-  Lists all saved model profiles.
+  Lists your models from the dashboard and lets you choose the current one for the CLI.
 
 - `semalt-code models add`
   Opens an interactive flow to add an API base URL, API key, and model ID as a reusable model profile.
@@ -137,7 +148,10 @@ Available interactive commands:
 
 - `/help`
 - `/file <path>`
+- `/whoami`
+- `/logout`
 - `/model`
+- `/login`
 - `/model <name>`
 - `/models`
 - `/clear`

package/index.js

@@ -74,7 +74,10 @@ Commands:
   code <prompt>     Generate code from a prompt
   edit <file> <instruction>  Edit a file with AI
   shell <command>   Run and optionally analyze a shell command
-  models            List saved model profiles
+  login             Authorize CLI via browser
+  whoami            Show current authorized user
+  logout            Clear current CLI login
+  models            Choose one of your dashboard models
   models add        Add a saved model profile
   init              Initialize config
 
@@ -85,6 +88,7 @@ Options:
   --dry-run               Don't save changes      (edit command)
   --api-base <url>        API base URL            (init)
   --api-key  <key>        API key                 (init)
+  --dashboard-url <url>   Dashboard URL           (init)
   --default-model <name>  Default model           (init)
   -v, --version           Show CLI version
 
@@ -110,6 +114,12 @@ Config: ${CONFIG_PATH}
   } else if (command === 'shell') {
     const { opts, positional } = parseArgs(rawArgs.slice(1));
     await commands.cmdShell(opts, positional);
+  } else if (command === 'login') {
+    await commands.cmdLogin();
+  } else if (command === 'whoami') {
+    await commands.cmdWhoAmI();
+  } else if (command === 'logout') {
+    await commands.cmdLogout();
   } else if (command === 'models') {
     if (rawArgs[1] === 'add') await commands.cmdModelsAdd();
     else await commands.cmdModels();

package/lib/api.js

@@ -27,10 +27,27 @@ function createApiClient({ getConfig, saveConfig, ui }) {
     return `${normalizedBase}${normalizedPath}`;
   }
 
+  function dashboardUrl(urlPath) {
+    const config = getConfig();
+    const base = (config.dashboard_url || '').replace(/\/$/, '');
+    const normalizedPath = urlPath.startsWith('/') ? urlPath : `/${urlPath}`;
+    return `${base}${normalizedPath}`;
+  }
+
   function describeModelProfile(profile) {
     return `${profile.model} @ ${profile.api_base}`;
   }
 
+  function requireAuthToken() {
+    const config = getConfig();
+    if (!config.auth_token) {
+      const error = new Error('Not logged in. Run semalt login first.');
+      error.statusCode = 401;
+      throw error;
+    }
+    return config.auth_token;
+  }
+
   function setActiveModelProfile(profile) {
     const config = getConfig();
     config.api_base = profile.api_base;
@@ -105,6 +122,107 @@ function createApiClient({ getConfig, saveConfig, ui }) {
     });
   }
 
+  async function requestJson(urlStr, { method = 'GET', timeout, headers = {}, body } = {}) {
+    const requestBody = body === undefined ? undefined : JSON.stringify(body);
+    const finalHeaders = { ...headers };
+    if (requestBody !== undefined) {
+      finalHeaders['Content-Type'] = 'application/json';
+      finalHeaders['Content-Length'] = Buffer.byteLength(requestBody);
+    }
+
+    const res = await httpRequest(urlStr, {
+      method,
+      timeout: timeout || getConfig().request_timeout_ms,
+      headers: finalHeaders,
+    }, requestBody);
+
+    return new Promise((resolve, reject) => {
+      let data = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+      res.on('end', () => {
+        let parsed = null;
+        try {
+          parsed = data ? JSON.parse(data) : null;
+        } catch {
+          parsed = data ? { error: data } : null;
+        }
+
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          const error = new Error((parsed && parsed.error) || `HTTP ${res.statusCode}`);
+          error.statusCode = res.statusCode;
+          error.data = parsed;
+          reject(error);
+          return;
+        }
+
+        resolve(parsed);
+      });
+      res.on('error', reject);
+    });
+  }
+
+  function requestCliLogin() {
+    return requestJson(dashboardUrl('/api/auth/cli/request'), {
+      method: 'POST',
+      timeout: 15000,
+    });
+  }
+
+  function getCliLoginStatus(id, hash) {
+    return requestJson(dashboardUrl('/api/auth/cli/status'), {
+      method: 'POST',
+      timeout: 15000,
+      body: { id, hash },
+    });
+  }
+
+  function dashboardWhoAmI() {
+    const authToken = requireAuthToken();
+    return requestJson(dashboardUrl('/api/auth/me'), {
+      method: 'GET',
+      timeout: 15000,
+      headers: {
+        'Authorization': `Bearer ${authToken}`,
+      },
+    });
+  }
+
+  function dashboardLogout() {
+    const authToken = requireAuthToken();
+    return requestJson(dashboardUrl('/api/auth/logout'), {
+      method: 'POST',
+      timeout: 15000,
+      headers: {
+        'Authorization': `Bearer ${authToken}`,
+      },
+    });
+  }
+
+  function dashboardListModels() {
+    const authToken = requireAuthToken();
+    return requestJson(dashboardUrl('/api/models'), {
+      method: 'GET',
+      timeout: 15000,
+      headers: {
+        'Authorization': `Bearer ${authToken}`,
+      },
+    });
+  }
+
+  function dashboardGetModelForCli(id) {
+    const authToken = requireAuthToken();
+    return requestJson(dashboardUrl(`/api/models/${encodeURIComponent(String(id))}/cli`), {
+      method: 'GET',
+      timeout: 15000,
+      headers: {
+        'Authorization': `Bearer ${authToken}`,
+      },
+    });
+  }
+
   async function chatStream(messages, { model, temperature, maxTokens } = {}) {
     const config = getConfig();
     const payload = {
@@ -271,8 +389,14 @@ function createApiClient({ getConfig, saveConfig, ui }) {
     chatStream,
     chatSync,
     chooseSavedModelProfile,
+    dashboardGetModelForCli,
+    dashboardListModels,
+    dashboardLogout,
+    dashboardWhoAmI,
     describeModelProfile,
     estimateTokens,
+    getCliLoginStatus,
+    requestCliLogin,
     setActiveModelProfile,
   };
 }

package/lib/args.js

@@ -28,6 +28,9 @@ function parseArgs(argv) {
       case '--api-key':
         opts.apiKey = argv[++i];
         break;
+      case '--dashboard-url':
+        opts.dashboardUrl = argv[++i];
+        break;
       case '--default-model':
         opts.defaultModel = argv[++i];
         break;

package/lib/commands.js

@@ -36,12 +36,24 @@ function createCommands({
   const {
     chatStream,
     chatSync,
-    chooseSavedModelProfile,
+    dashboardGetModelForCli,
+    dashboardListModels,
+    dashboardLogout,
+    dashboardWhoAmI,
     describeModelProfile,
     estimateTokens,
+    getCliLoginStatus,
+    requestCliLogin,
     setActiveModelProfile,
   } = apiClient;
 
+  const LOGIN_POLL_INTERVAL_MS = 2000;
+  const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+
+  function formatUserLine(label, value) {
+    return `  ${FG_CYAN}${label}:${RST} ${FG_GRAY}${value}${RST}`;
+  }
+
   async function cmdChat(opts) {
     printBanner();
     const cwd = process.cwd();
@@ -87,9 +99,12 @@ function createCommands({
         console.log(`
   ${FG_BLUE}${BOLD}Commands:${RST}
   ${FG_CYAN}/file <path>${RST}     ${FG_GRAY}Load file or dir into context${RST}
-  ${FG_CYAN}/model${RST}           ${FG_GRAY}Choose saved model profile${RST}
+  ${FG_CYAN}/login${RST}           ${FG_GRAY}Authorize this CLI via browser${RST}
+  ${FG_CYAN}/whoami${RST}          ${FG_GRAY}Show current authorized user${RST}
+  ${FG_CYAN}/logout${RST}          ${FG_GRAY}Clear current CLI login${RST}
+  ${FG_CYAN}/model${RST}           ${FG_GRAY}Show or set current model id${RST}
   ${FG_CYAN}/model <name>${RST}    ${FG_GRAY}Switch model manually${RST}
-  ${FG_CYAN}/models${RST}          ${FG_GRAY}Choose saved model profile${RST}
+  ${FG_CYAN}/models${RST}          ${FG_GRAY}Choose one of your dashboard models${RST}
   ${FG_CYAN}/clear${RST}           ${FG_GRAY}Clear conversation${RST}
   ${FG_CYAN}/compact${RST}         ${FG_GRAY}Show token usage${RST}
   ${FG_CYAN}/shell <cmd>${RST}     ${FG_GRAY}Run shell command directly${RST}
@@ -103,6 +118,23 @@ function createCommands({
         continue;
       }
 
+      if (text === '/login') {
+        await cmdLogin();
+        printStatusBar(currentModel, cwd);
+        continue;
+      }
+
+      if (text === '/whoami') {
+        await cmdWhoAmI();
+        continue;
+      }
+
+      if (text === '/logout') {
+        await cmdLogout();
+        printStatusBar(currentModel, cwd);
+        continue;
+      }
+
       if (text.startsWith('/file ')) {
         const fp = text.slice(6).trim();
         const ctx = readFileContext([fp], ui);
@@ -110,19 +142,13 @@ function createCommands({
         continue;
       }
 
-      if (text === '/model' || text === '/models') {
-        await new Promise((resolve) => {
-          const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-            terminal: true,
-          });
-          chooseSavedModelProfile(rl, currentModel, cwd, (nextModel) => {
-            currentModel = nextModel;
-            rl.close();
-            resolve();
-          });
-        });
+      if (text === '/models') {
+        currentModel = await cmdModels(currentModel, cwd);
+        continue;
+      }
+
+      if (text === '/model') {
+        console.log(`  ${FG_GRAY}Current model: ${currentModel}${RST}\n`);
         continue;
       }
 
@@ -255,22 +281,71 @@ function createCommands({
 
   async function cmdModels() {
     const config = getConfig();
-    if (!config.models.length) {
-      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}No saved model profiles. Use semalt-code models add first.${RST}`);
-      return;
+    let response;
+    try {
+      response = await dashboardListModels();
+    } catch (error) {
+      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}${error.message}${RST}\n`);
+      return config.default_model;
+    }
+
+    const models = Array.isArray(response && response.models) ? response.models : [];
+    if (!models.length) {
+      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}No models found in your dashboard account.${RST}\n`);
+      return config.default_model;
     }
 
     console.log();
-    console.log(`  ${FG_TEAL}${BOLD}◆ Saved Models${RST}`);
-    console.log(`  ${FG_DARK}${'─'.repeat(40)}${RST}`);
-    config.models.forEach((profile, index) => {
-      const active = profile.api_base === config.api_base &&
-        profile.api_key === config.api_key &&
-        profile.model === config.default_model;
+    console.log(`  ${FG_TEAL}${BOLD}◆ Your Models${RST}`);
+    console.log(`  ${FG_DARK}${'─'.repeat(60)}${RST}`);
+    models.forEach((model, index) => {
+      const active = model.base_url === config.api_base && model.model_id === config.default_model;
       const marker = active ? `${FG_GREEN}●${RST}` : `${FG_DARK}○${RST}`;
-      console.log(`  ${marker} ${FG_CYAN}${index + 1}.${RST} ${describeModelProfile(profile)}`);
+      console.log(`  ${marker} ${FG_CYAN}${index + 1}.${RST} ${FG_GRAY}${model.name} · ${model.model_id} @ ${model.base_url}${RST}`);
     });
     console.log();
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true,
+    });
+
+    const selectedIndex = await new Promise((resolve) => {
+      rl.question(`  ${FG_TEAL}${BOLD}Select model>${RST} `, (answer) => {
+        rl.close();
+        resolve(Number((answer || '').trim()));
+      });
+    });
+
+    if (!Number.isInteger(selectedIndex) || selectedIndex < 1 || selectedIndex > models.length) {
+      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Invalid selection${RST}\n`);
+      return config.default_model;
+    }
+
+    const selectedModel = models[selectedIndex - 1];
+    let credentialsResponse;
+    try {
+      credentialsResponse = await dashboardGetModelForCli(selectedModel.id);
+    } catch (error) {
+      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}${error.message}${RST}\n`);
+      return config.default_model;
+    }
+
+    const model = credentialsResponse && credentialsResponse.model ? credentialsResponse.model : null;
+    if (!model) {
+      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Unable to load selected model.${RST}\n`);
+      return config.default_model;
+    }
+
+    setConfig({
+      ...config,
+      api_base: model.base_url,
+      api_key: model.api_key,
+      default_model: model.model_id,
+    });
+    console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Current model → ${model.name} (${model.model_id})${RST}\n`);
+    return model.model_id;
   }
 
   async function cmdModelsAdd() {
@@ -317,6 +392,8 @@ function createCommands({
     const cfg = {
       api_base: opts.apiBase || 'http://127.0.0.1:8800',
       api_key: opts.apiKey || 'any',
+      dashboard_url: opts.dashboardUrl || current.dashboard_url,
+      auth_token: current.auth_token || '',
       default_model: opts.defaultModel || 'default',
       temperature: 0.7,
       request_timeout_ms: DEFAULT_API_TIMEOUT_MS,
@@ -328,14 +405,120 @@ function createCommands({
     console.log(`  ${FG_GRAY}${JSON.stringify(cfg, null, 2)}${RST}\n`);
   }
 
+  async function cmdLogin() {
+    console.log();
+    console.log(`  ${FG_TEAL}${BOLD}◆ CLI Login${RST}`);
+    console.log(`  ${FG_DARK}${'─'.repeat(40)}${RST}`);
+
+    let loginRequest;
+    try {
+      loginRequest = await requestCliLogin();
+    } catch (error) {
+      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Unable to start login via ${getConfig().dashboard_url}: ${error.message}${RST}\n`);
+      return;
+    }
+
+    console.log(`  ${FG_GRAY}Open this URL in your browser and confirm the login:${RST}`);
+    console.log(`  ${FG_CYAN}${loginRequest.verification_url}${RST}`);
+    console.log(`  ${FG_DARK}Waiting for confirmation...${RST}`);
+
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < LOGIN_TIMEOUT_MS) {
+      await new Promise((resolve) => setTimeout(resolve, LOGIN_POLL_INTERVAL_MS));
+
+      let status;
+      try {
+        status = await getCliLoginStatus(loginRequest.id, loginRequest.hash);
+      } catch (error) {
+        if (error.statusCode === 404 || error.statusCode === 410) {
+          console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Login token is no longer valid.${RST}\n`);
+          return;
+        }
+        continue;
+      }
+
+      if (status.status === 'authorized') {
+        const config = getConfig();
+        setConfig({
+          ...config,
+          dashboard_url: config.dashboard_url,
+          auth_token: loginRequest.token,
+        });
+        console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}CLI token saved to ${CONFIG_PATH}${RST}\n`);
+        return;
+      }
+
+      if (status.status === 'expired') {
+        console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Login token expired. Run semalt login again.${RST}\n`);
+        return;
+      }
+    }
+
+    console.log(`  ${FG_YELLOW}⚠${RST} ${FG_GRAY}Login timed out. The URL may still work for a short time.${RST}\n`);
+  }
+
+  async function cmdWhoAmI() {
+    let response;
+    try {
+      response = await dashboardWhoAmI();
+    } catch (error) {
+      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}${error.message}${RST}\n`);
+      return;
+    }
+
+    const user = response && response.user ? response.user : null;
+    if (!user) {
+      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Unable to load current user.${RST}\n`);
+      return;
+    }
+
+    console.log();
+    console.log(`  ${FG_TEAL}${BOLD}◆ Current User${RST}`);
+    console.log(`  ${FG_DARK}${'─'.repeat(40)}${RST}`);
+    console.log(formatUserLine('ID', user.id));
+    console.log(formatUserLine('Email', user.email || '-'));
+    console.log(formatUserLine('Name', user.name || '-'));
+    console.log(formatUserLine('Provider', user.provider || '-'));
+    if (user.avatar_url) {
+      console.log(formatUserLine('Avatar', user.avatar_url));
+    }
+    console.log();
+  }
+
+  async function cmdLogout() {
+    const config = getConfig();
+    if (!config.auth_token) {
+      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Not logged in. Run semalt login first.${RST}\n`);
+      return;
+    }
+
+    try {
+      await dashboardLogout();
+    } catch (error) {
+      if (error.statusCode !== 401) {
+        console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}${error.message}${RST}\n`);
+        return;
+      }
+    }
+
+    setConfig({
+      ...config,
+      auth_token: '',
+    });
+    console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Logged out and cleared local CLI token.${RST}\n`);
+  }
+
   return {
     cmdChat,
     cmdCode,
     cmdEdit,
     cmdInit,
+    cmdLogin,
     cmdModels,
     cmdModelsAdd,
     cmdShell,
+    cmdLogout,
+    cmdWhoAmI,
   };
 }
 

package/lib/config.js

@@ -7,6 +7,23 @@ const { CONFIG_PATH, DEFAULT_CONFIG } = require('./constants');
 
 function normalizeConfig(cfg = {}) {
   const merged = { ...DEFAULT_CONFIG, ...cfg };
+  const legacyDashboardUrl = typeof cfg.semalt_base_url === 'string' && cfg.semalt_base_url.trim()
+    ? cfg.semalt_base_url.trim()
+    : '';
+  const requestedDashboardUrl = typeof cfg.dashboard_url === 'string' ? cfg.dashboard_url.trim() : '';
+  merged.api_base = typeof merged.api_base === 'string' ? merged.api_base.trim() : DEFAULT_CONFIG.api_base;
+  merged.api_key = typeof merged.api_key === 'string' ? merged.api_key : DEFAULT_CONFIG.api_key;
+  if (requestedDashboardUrl) {
+    merged.dashboard_url = requestedDashboardUrl;
+  } else if (legacyDashboardUrl) {
+    merged.dashboard_url = legacyDashboardUrl;
+  } else {
+    merged.dashboard_url = DEFAULT_CONFIG.dashboard_url;
+  }
+  merged.auth_token = typeof merged.auth_token === 'string' ? merged.auth_token : '';
+  merged.default_model = typeof merged.default_model === 'string' && merged.default_model.trim()
+    ? merged.default_model.trim()
+    : DEFAULT_CONFIG.default_model;
   merged.models = Array.isArray(cfg.models)
     ? cfg.models
         .filter((entry) => entry &&

package/lib/constants.js

@@ -10,6 +10,8 @@ const DEFAULT_API_TIMEOUT_MS = 15 * 60 * 1000;
 const DEFAULT_CONFIG = {
   api_base: 'http://127.0.0.1:8800',
   api_key: 'any',
+  dashboard_url: 'https://cli.semalt.ai',
+  auth_token: '',
   default_model: 'default',
   temperature: 0.7,
   request_timeout_ms: DEFAULT_API_TIMEOUT_MS,

package/lib/ui.js

@@ -111,133 +111,279 @@ function readInteractiveInput(promptText, options = {}) {
     let done = false;
     let historyIndex = Array.isArray(history) ? history.length : -1;
     let historyActive = false;
+    let pasting = false;
+    let lastLineCount = 1;
+    let lastCursorRow = 0;
+    let lastWasCR = false;
 
-    readline.emitKeypressEvents(process.stdin);
     process.stdin.setRawMode(true);
     process.stdin.resume();
+    process.stdout.write('\x1b[?2004h'); // enable bracketed paste mode
+
+    const promptWidth = stripAnsi(promptText).length;
 
     const render = () => {
+      const lines = buffer.split('\n');
+      const newLineCount = lines.length;
+
+      if (lastLineCount > 1) {
+        readline.moveCursor(process.stdout, 0, -(lastLineCount - 1));
+      }
+
       readline.cursorTo(process.stdout, 0);
       readline.clearLine(process.stdout, 0);
-      process.stdout.write(`${promptText}${buffer}`);
-      const promptWidth = stripAnsi(promptText).length;
-      readline.cursorTo(process.stdout, promptWidth + cursor);
+      process.stdout.write(`${promptText}${lines[0]}`);
+
+      for (let i = 1; i < newLineCount; i++) {
+        process.stdout.write('\n');
+        readline.cursorTo(process.stdout, 0);
+        readline.clearLine(process.stdout, 0);
+        process.stdout.write(lines[i]);
+      }
+
+      // Clear any extra lines from a previous longer render
+      for (let i = newLineCount; i < lastLineCount; i++) {
+        process.stdout.write('\n');
+        readline.cursorTo(process.stdout, 0);
+        readline.clearLine(process.stdout, 0);
+      }
+
+      lastLineCount = newLineCount;
+
+      const beforeCursor = Array.from(buffer).slice(0, cursor).join('');
+      const cursorLines = beforeCursor.split('\n');
+      lastCursorRow = cursorLines.length - 1;
+      const cursorCol = (lastCursorRow === 0 ? promptWidth : 0) + cursorLines[lastCursorRow].length;
+
+      const rowsFromBottom = newLineCount - 1 - lastCursorRow;
+      if (rowsFromBottom > 0) {
+        readline.moveCursor(process.stdout, 0, -rowsFromBottom);
+      }
+      readline.cursorTo(process.stdout, cursorCol);
     };
 
     const finish = (result, addNewline = true) => {
       if (done) return;
       done = true;
+      process.stdout.write('\x1b[?2004l'); // disable bracketed paste mode
       process.stdin.setRawMode(wasRaw);
-      process.stdin.removeListener('keypress', onKeypress);
-      if (addNewline) process.stdout.write('\n');
+      process.stdin.removeListener('data', onData);
+      if (addNewline) {
+        const rowsToBottom = lastLineCount - 1 - lastCursorRow;
+        if (rowsToBottom > 0) {
+          readline.moveCursor(process.stdout, 0, rowsToBottom);
+        }
+        process.stdout.write('\n');
+      }
       resolve(result);
     };
 
-    const onKeypress = (str, key = {}) => {
-      if (key.ctrl && key.name === 'c') {
-        if (buffer) {
-          buffer = '';
-          cursor = 0;
-          render();
-          return;
+    // Parse raw stdin data directly so we can intercept bracketed paste markers
+    // (\x1b[200~ ... \x1b[201~) before any higher-level key parser sees them.
+    const onData = (chunk) => {
+      if (done) return;
+      const data = chunk.toString('utf8');
+      let i = 0;
+
+      while (i < data.length) {
+        // --- Bracketed paste markers ---
+        if (data.startsWith('\x1b[200~', i)) {
+          pasting = true;
+          lastWasCR = false;
+          i += 6;
+          continue;
+        }
+        if (data.startsWith('\x1b[201~', i)) {
+          pasting = false;
+          lastWasCR = false;
+          i += 6;
+          continue;
         }
-        finish({ type: 'sigint' }, false);
-        return;
-      }
 
-      if (key.ctrl && key.name === 'd') {
-        if (!buffer) finish({ type: 'eof' }, false);
-        return;
-      }
+        const ch = data[i];
+
+        // --- Escape sequences ---
+        if (ch === '\x1b') {
+          lastWasCR = false;
+          const next = data[i + 1];
+
+          // CSI sequences: \x1b[...
+          if (next === '[') {
+            const seq3 = data.slice(i, i + 3);
+            const seq4 = data.slice(i, i + 4);
+
+            if (seq3 === '\x1b[A') { // up
+              if (Array.isArray(history) && history.length) {
+                if (historyActive || buffer.length === 0) {
+                  historyActive = true;
+                  historyIndex = Math.max(0, historyIndex - 1);
+                  buffer = historyIndex >= history.length ? '' : history[historyIndex];
+                  cursor = Array.from(buffer).length;
+                  render();
+                }
+              }
+              i += 3; continue;
+            }
+            if (seq3 === '\x1b[B') { // down
+              if (Array.isArray(history) && history.length) {
+                if (historyActive || buffer.length === 0) {
+                  historyActive = true;
+                  historyIndex = Math.min(history.length, historyIndex + 1);
+                  buffer = historyIndex >= history.length ? '' : history[historyIndex];
+                  cursor = Array.from(buffer).length;
+                  render();
+                }
+              }
+              i += 3; continue;
+            }
+            if (seq3 === '\x1b[C') { // right
+              if (allowCursorNavigation && cursor < Array.from(buffer).length) { cursor++; render(); }
+              i += 3; continue;
+            }
+            if (seq3 === '\x1b[D') { // left
+              if (allowCursorNavigation && cursor > 0) { cursor--; render(); }
+              i += 3; continue;
+            }
+            if (seq3 === '\x1b[H' || seq4 === '\x1b[1~') { // home
+              if (allowCursorNavigation) { cursor = 0; render(); }
+              i += (seq3 === '\x1b[H' ? 3 : 4); continue;
+            }
+            if (seq3 === '\x1b[F' || seq4 === '\x1b[4~') { // end
+              if (allowCursorNavigation) { cursor = Array.from(buffer).length; render(); }
+              i += (seq3 === '\x1b[F' ? 3 : 4); continue;
+            }
+            if (seq4 === '\x1b[3~') { // delete
+              if (cursor < Array.from(buffer).length) {
+                buffer = removeCharAt(buffer, cursor);
+                historyActive = false;
+                render();
+              }
+              i += 4; continue;
+            }
+            // Skip unknown CSI sequence (read until terminating byte)
+            let j = i + 2;
+            while (j < data.length && (data.charCodeAt(j) < 0x40 || data.charCodeAt(j) > 0x7e)) j++;
+            i = j + 1;
+            continue;
+          }
+
+          // SS3 sequences: \x1bO... (application cursor keys)
+          if (next === 'O') {
+            const c = data[i + 2];
+            if (c === 'A') { // up
+              if (Array.isArray(history) && history.length && (historyActive || buffer.length === 0)) {
+                historyActive = true;
+                historyIndex = Math.max(0, historyIndex - 1);
+                buffer = historyIndex >= history.length ? '' : history[historyIndex];
+                cursor = Array.from(buffer).length;
+                render();
+              }
+              i += 3; continue;
+            }
+            if (c === 'B') { // down
+              if (Array.isArray(history) && history.length && (historyActive || buffer.length === 0)) {
+                historyActive = true;
+                historyIndex = Math.min(history.length, historyIndex + 1);
+                buffer = historyIndex >= history.length ? '' : history[historyIndex];
+                cursor = Array.from(buffer).length;
+                render();
+              }
+              i += 3; continue;
+            }
+            if (c === 'C' && allowCursorNavigation) { if (cursor < Array.from(buffer).length) { cursor++; render(); } i += 3; continue; }
+            if (c === 'D' && allowCursorNavigation) { if (cursor > 0) { cursor--; render(); } i += 3; continue; }
+            if (c === 'H' && allowCursorNavigation) { cursor = 0; render(); i += 3; continue; }
+            if (c === 'F' && allowCursorNavigation) { cursor = Array.from(buffer).length; render(); i += 3; continue; }
+            i += 3; continue;
+          }
+
+          // Unknown escape - skip
+          i += 2;
+          continue;
+        }
 
-      if (key.name === 'return' || key.name === 'enter') {
-        finish({ type: 'submit', value: trim ? buffer.trim() : buffer });
-        return;
-      }
+        // --- Ctrl+C ---
+        if (ch === '\x03') {
+          lastWasCR = false;
+          if (buffer) { buffer = ''; cursor = 0; pasting = false; render(); }
+          else { finish({ type: 'sigint' }, false); return; }
+          i++; continue;
+        }
 
-      if (key.name === 'backspace' || key.name === 'delete') {
-        if (key.name === 'backspace' && cursor > 0) {
-          buffer = removeCharAt(buffer, cursor - 1);
-          cursor--;
-          historyActive = false;
-          render();
-        } else if (key.name === 'delete' && cursor < Array.from(buffer).length) {
-          buffer = removeCharAt(buffer, cursor);
-          historyActive = false;
-          render();
+        // --- Ctrl+D ---
+        if (ch === '\x04') {
+          lastWasCR = false;
+          if (!buffer) { finish({ type: 'eof' }, false); return; }
+          i++; continue;
         }
-        return;
-      }
 
-      if (allowCursorNavigation && key.name === 'left') {
-        if (cursor > 0) {
-          cursor--;
-          render();
+        // --- Enter / newline ---
+        if (ch === '\r' || ch === '\n') {
+          // Collapse CRLF into a single newline
+          if (ch === '\n' && lastWasCR) { lastWasCR = false; i++; continue; }
+          lastWasCR = (ch === '\r');
+
+          if (pasting) {
+            buffer = insertCharAt(buffer, cursor, '\n');
+            cursor++;
+            historyActive = false;
+            render();
+          } else {
+            finish({ type: 'submit', value: trim ? buffer.trim() : buffer });
+            return;
+          }
+          i++; continue;
+        }
+        lastWasCR = false;
+
+        // --- Backspace ---
+        if (ch === '\x7f' || ch === '\x08') {
+          if (cursor > 0) {
+            buffer = removeCharAt(buffer, cursor - 1);
+            cursor--;
+            historyActive = false;
+            render();
+          }
+          i++; continue;
         }
-        return;
-      }
 
-      if (allowCursorNavigation && key.name === 'right') {
-        if (cursor < Array.from(buffer).length) {
-          cursor++;
-          render();
+        // --- Tab ---
+        if (ch === '\t') {
+          if (pasting) {
+            buffer = insertCharAt(buffer, cursor, '\t');
+            cursor++;
+            render();
+          }
+          i++; continue;
         }
-        return;
-      }
 
-      if (allowCursorNavigation && key.name === 'home') {
-        cursor = 0;
-        render();
-        return;
-      }
+        // --- Other control characters: skip ---
+        if (ch.charCodeAt(0) < 0x20) { i++; continue; }
 
-      if (allowCursorNavigation && key.name === 'end') {
-        cursor = Array.from(buffer).length;
-        render();
-        return;
-      }
+        // --- Printable character (handles multi-byte Unicode via code points) ---
+        const cp = data.codePointAt(i);
+        const char = String.fromCodePoint(cp);
 
-      if (Array.isArray(history) && (key.name === 'up' || key.name === 'down')) {
-        const canEnterHistory = buffer.length === 0;
-        if (!history.length) return;
-        if (!historyActive && !canEnterHistory) return;
+        if (allowed && !allowed.includes(char)) { i += char.length; continue; }
 
-        historyActive = true;
-        if (key.name === 'up') {
-          historyIndex = Math.max(0, historyIndex - 1);
-        } else {
-          historyIndex = Math.min(history.length, historyIndex + 1);
+        if (immediate) {
+          buffer = char;
+          cursor = 1;
+          historyActive = false;
+          render();
+          finish({ type: 'submit', value: char });
+          return;
         }
 
-        buffer = historyIndex >= history.length ? '' : history[historyIndex];
-        cursor = Array.from(buffer).length;
-        render();
-        return;
-      }
-
-      if (key.name && ['up', 'down', 'left', 'right', 'home', 'end', 'pageup', 'pagedown', 'escape', 'tab'].includes(key.name)) {
-        return;
-      }
-
-      if (!isPrintableKey(str, key)) return;
-      if (allowed && !allowed.includes(str)) return;
-
-      if (immediate) {
-        buffer = str;
-        cursor = Array.from(buffer).length;
+        buffer = insertCharAt(buffer, cursor, char);
+        cursor++;
         historyActive = false;
         render();
-        finish({ type: 'submit', value: str });
-        return;
+        i += char.length;
       }
-
-      buffer = insertCharAt(buffer, cursor, str);
-      cursor++;
-      historyActive = false;
-      render();
     };
 
-    process.stdin.on('keypress', onKeypress);
+    process.stdin.on('data', onData);
     render();
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semalt-ai/code",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "Self-hosted AI Coding Assistant CLI",
   "main": "index.js",
   "bin": {