@semalt-ai/code 1.8.5 → 1.19.0

package/lib/commands/auth.js

@@ -0,0 +1,94 @@
+'use strict';
+
+// Authentication / account CLI commands, extracted from lib/commands.js in
+// Task 1.5. `shared` is the dependency bag built by createCommands; it is
+// destructured once here so the command bodies below are unchanged.
+
+function createAuthCommands(shared) {
+  const {
+    writer, getConfig, setConfig,
+    requestCliLogin, getCliLoginStatus, dashboardWhoAmI, dashboardLogout,
+    formatUserLine, keychainSet, ENV_VAR, CONFIG_PATH,
+    LOGIN_POLL_INTERVAL_MS, LOGIN_TIMEOUT_MS,
+    FG_RED, FG_GRAY, FG_TEAL, FG_DARK, FG_GREEN, FG_CYAN, FG_YELLOW, BOLD, RST,
+  } = shared;
+
+  async function cmdLogin() {
+    writer.scrollback(`\n  ${FG_TEAL}${BOLD}◆ CLI Login${RST}\n  ${FG_DARK}${'─'.repeat(40)}${RST}`);
+    let loginRequest;
+    try { loginRequest = await requestCliLogin(); }
+    catch (err) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}Unable to start login via ${getConfig().dashboard_url}: ${err.message}${RST}\n`); return; }
+    writer.scrollback(`  ${FG_GRAY}Open this URL in your browser and confirm the login:${RST}\n  ${FG_CYAN}${loginRequest.verification_url}${RST}\n  ${FG_DARK}Waiting for confirmation...${RST}`);
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < LOGIN_TIMEOUT_MS) {
+      await new Promise((r) => setTimeout(r, LOGIN_POLL_INTERVAL_MS));
+      let status;
+      try { status = await getCliLoginStatus(loginRequest.id, loginRequest.hash); }
+      catch (err) { if (err.statusCode === 404 || err.statusCode === 410) { writer.scrollback(`  ${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 }); writer.scrollback(`  ${FG_GREEN}✓${RST} ${FG_GRAY}CLI token saved to ${CONFIG_PATH}${RST}\n`); return; }
+      if (status.status === 'expired') { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}Login token expired.${RST}\n`); return; }
+    }
+    writer.scrollback(`  ${FG_YELLOW}⚠${RST} ${FG_GRAY}Login timed out.${RST}\n`);
+  }
+
+  async function cmdWhoAmI() {
+    let response;
+    try { response = await dashboardWhoAmI(); } catch (err) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}${err.message}${RST}\n`); return; }
+    const user = response && response.user ? response.user : null;
+    if (!user) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}Unable to load current user.${RST}\n`); return; }
+    const lines = [
+      '',
+      `  ${FG_TEAL}${BOLD}◆ Current User${RST}`,
+      `  ${FG_DARK}${'─'.repeat(40)}${RST}`,
+      formatUserLine('ID', user.id),
+      formatUserLine('Email', user.email || '-'),
+      formatUserLine('Name', user.name || '-'),
+      formatUserLine('Provider', user.provider || '-'),
+    ];
+    if (user.avatar_url) lines.push(formatUserLine('Avatar', user.avatar_url));
+    lines.push('');
+    writer.scrollback(lines.join('\n'));
+  }
+
+  async function cmdLogout() {
+    const config = getConfig();
+    if (!config.auth_token) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}Not logged in.${RST}\n`); return; }
+    try { await dashboardLogout(); } catch (err) { if (err.statusCode !== 401) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}${err.message}${RST}\n`); return; } }
+    setConfig({ ...config, auth_token: '' });
+    writer.scrollback(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Logged out and cleared local CLI token.${RST}\n`);
+  }
+
+  // `semalt-code auth set-key [key]` — store the API key in the OS keychain so
+  // it is no longer kept in plaintext in config.json. If [key] is omitted, read
+  // it from stdin (so it does not land in shell history / the process table).
+  async function cmdAuthSetKey(keyArg) {
+    let key = typeof keyArg === 'string' ? keyArg.trim() : '';
+    if (!key) {
+      if (process.stdin.isTTY) {
+        process.stdout.write(`  ${FG_GRAY}Paste API key (input hidden is not available; press Enter when done):${RST}\n  > `);
+      }
+      key = await new Promise((resolve) => {
+        let buf = '';
+        const onData = (d) => { buf += d; if (buf.includes('\n')) { process.stdin.pause(); process.stdin.off('data', onData); resolve(buf.split('\n')[0]); } };
+        try { process.stdin.resume(); process.stdin.setEncoding('utf8'); process.stdin.on('data', onData); } catch { resolve(''); }
+      });
+      key = (key || '').trim();
+    }
+    if (!key) {
+      writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}No key provided.${RST}\n`);
+      return;
+    }
+    const ok = keychainSet(key);
+    if (ok) {
+      writer.scrollback(`  ${FG_GREEN}✓${RST} ${FG_GRAY}API key stored in the OS keychain. It will be used automatically (env var still takes precedence).${RST}\n`);
+      writer.scrollback(`  ${FG_DARK}It is NOT written to config.json. Verify with 'semalt-code config' → api_key_source: keychain.${RST}\n`);
+    } else {
+      writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}Could not store the key in the OS keychain (native tool missing or unavailable on this platform).${RST}\n`);
+      writer.scrollback(`  ${FG_DARK}Alternative: set the ${ENV_VAR} environment variable instead.${RST}\n`);
+    }
+  }
+
+  return { cmdLogin, cmdWhoAmI, cmdLogout, cmdAuthSetKey };
+}
+
+module.exports = { createAuthCommands };

package/lib/commands/chat-session.js

@@ -0,0 +1,306 @@
+'use strict';
+
+// Chat session/state management extracted from cmdChat in Task 1.5: local- and
+// dashboard-history sync plus the in-chat picker (history / chats / models).
+// Bodies are unchanged except that mutable session fields are read/written
+// through ctx (the getter/setter hub built in cmdChat) instead of as closure
+// locals; stable collaborators are destructured from ctx once below. The
+// functions call each other by bare name (same module scope); other chat
+// modules reach them via ctx, onto which createCommands' cmdChat assigns them.
+
+function createChatSession(ctx) {
+  const {
+    storage, inputField, chatHistory, statusBar, writer, msgs,
+    getConfig, setConfig, getCols, approxTokens, PAGE_SIZE, sessionStart,
+    dashboardCreateChat, dashboardSaveMessages, dashboardGetChat, dashboardGetModelForCli,
+    cleanOrphanedToolMessages, reconstructLoadedMessage, resolveTokenLimit,
+    FG_GRAY, RST,
+  } = ctx;
+
+  function refreshInputSearchItems(extraItems) {
+    const sessions = storage.list();
+    const items = sessions.map(s => ({
+      type: 'session',
+      text: (() => {
+        const date = new Date(s.created_at).toISOString().slice(0, 16).replace('T', ' ');
+        return `${date} ${s.model || ''} (${s.message_count} msgs)`;
+      })(),
+    }));
+    if (extraItems) items.push(...extraItems);
+    inputField.setSearchItems(items);
+  }
+
+  function saveSession() {
+    ctx.session.model = ctx.currentModel;
+    ctx.session.messages = ctx.messages;
+    ctx.session.stats.duration_sec = Math.round((Date.now() - sessionStart) / 1000);
+    ctx.session.stats.total_tokens = ctx.messages.reduce((s, m) => s + Math.round((m.content || '').length / 4), 0);
+    try { storage.save(ctx.session); } catch {}
+  }
+
+  async function createChatIfNeeded(firstUserText) {
+    const config = getConfig();
+    if (ctx.currentChatId !== null || !config.auth_token || !config.dashboard_model_id) return;
+    try {
+      const title = firstUserText.length > 60 ? firstUserText.slice(0, 57) + '...' : firstUserText;
+      const resp = await dashboardCreateChat(title, config.dashboard_model_id);
+      if (resp && resp.chat && resp.chat.id) ctx.currentChatId = resp.chat.id;
+    } catch {}
+  }
+
+  async function saveTurnToDashboard() {
+    if (ctx.currentChatId === null) return;
+    const newMessages = ctx.messages.slice(ctx.savedUpTo).filter((m) => m.role !== 'system');
+    if (!newMessages.length) return;
+    try {
+      const resp = await dashboardSaveMessages(ctx.currentChatId, newMessages);
+      ctx.savedUpTo = ctx.messages.length;
+      if (resp && typeof resp.skipped_count === 'number' && resp.skipped_count > 0) {
+        msgs.sysWarn(`history save: ${resp.skipped_count} message(s) skipped by server`);
+      }
+    } catch (err) {
+      msgs.sysWarn(`history save failed: ${err && err.message ? err.message : String(err)}`);
+    }
+  }
+
+  function displayLoadedMessages(loadedMessages) {
+    chatHistory.clearMessages();
+    for (const m of loadedMessages) {
+      if (m.role !== 'user' && m.role !== 'assistant' && m.role !== 'tool') continue;
+      const raw = typeof m.content === 'string' ? m.content : '';
+      const ts = m.created_at ? new Date(m.created_at) : (m.ts ? new Date(m.ts) : new Date());
+
+      if (m.role === 'tool') {
+        chatHistory.addMessage({ role: 'tool', tag: 'tool', content: raw, ts });
+        continue;
+      }
+
+      if (m.role === 'user' && raw.startsWith('Tool execution results:')) {
+        const body = raw
+          .replace(/^Tool execution results[^\n]*\n+/, '')
+          .replace(/\n+Continue with the task\.[\s\S]*$/, '')
+          .trim();
+        chatHistory.addMessage({ role: 'tool', tag: 'tool', content: body || raw, ts });
+        continue;
+      }
+
+      if (!raw.trim()) continue;
+      chatHistory.addMessage({ role: m.role, content: raw, ts });
+    }
+  }
+
+  function seedContextFromMessages() {
+    let total = 0;
+    for (const m of ctx.messages) {
+      if (typeof m.content === 'string') total += approxTokens(m.content);
+    }
+    statusBar.updateMetrics({ contextTokens: total });
+  }
+
+  function emitCleanupWarning(cleanup) {
+    if (cleanup.droppedTool === 0 && cleanup.droppedAssistantCalls === 0 && cleanup.droppedAssistantMsgs === 0) return;
+    const parts = [];
+    if (cleanup.droppedTool > 0) parts.push(`${cleanup.droppedTool} orphaned tool result(s)`);
+    if (cleanup.droppedAssistantCalls > 0) parts.push(`${cleanup.droppedAssistantCalls} dangling tool_call(s)`);
+    if (cleanup.droppedAssistantMsgs > 0) parts.push(`${cleanup.droppedAssistantMsgs} empty assistant message(s)`);
+    chatHistory.addMessage({
+      role: 'system',
+      content: `⚠ Loaded chat had ${parts.join(', ')}, cleaned up. The chat may be missing some context.`,
+    });
+  }
+
+  // ── In-chat picker (history / chats / models) ────────────────────────────
+
+  function getNavSearchText(type, item) {
+    if (type === 'history') {
+      const date = new Date(item.created_at).toISOString().slice(0, 16);
+      return `${date} ${item.model || ''} ${item.message_count || ''}`;
+    } else if (type === 'chats') {
+      return `${item.title || ''} ${item.model_name || ''}`;
+    } else if (type === 'models') {
+      return `${item.name || ''} ${item.model_id || ''}`;
+    }
+    return '';
+  }
+
+  function buildItemDetail(type, item) {
+    const cfg = getConfig();
+    const maxDetail = Math.max(20, getCols() - 12);
+    let detail = '';
+    if (type === 'history') {
+      const date = new Date(item.created_at).toISOString().slice(0, 16).replace('T', ' ');
+      detail = `${date}  ${(item.model || '').slice(0, 20)}  (${item.message_count} msgs)`;
+    } else if (type === 'chats') {
+      const date = item.updated_at ? String(item.updated_at).slice(0, 10) : '';
+      detail = `${item.title}  ·  ${item.model_name || ''}  ·  ${date}`;
+    } else if (type === 'models') {
+      const active = item.base_url === cfg.api_base && item.model_id === cfg.default_model;
+      detail = `${active ? '●' : ' '}  ${item.name}  ·  ${item.model_id}`;
+    }
+    if (detail.length > maxDetail) detail = detail.slice(0, maxDetail - 1) + '…';
+    return detail;
+  }
+
+  function buildListContent() {
+    if (!ctx.pendingAction) return '';
+    const { type, items, displayItems: di, stepIdx, searchQuery } = ctx.pendingAction;
+    const items2 = di || items;
+    const page = Math.floor(stepIdx / PAGE_SIZE);
+    const pageCount = Math.ceil(items2.length / PAGE_SIZE);
+    const pageStart = page * PAGE_SIZE;
+    const pageItems = items2.slice(pageStart, pageStart + PAGE_SIZE);
+    const localIdx = stepIdx - pageStart;
+    const titleMap = { history: 'Sessions', chats: 'Chats', models: 'Models' };
+    const pageLabel = pageCount > 1 ? `  · Page ${page + 1}/${pageCount}` : '';
+    const countLabel = items2.length > 0 ? `[${stepIdx + 1}/${items2.length}]` : '[0 results]';
+    const searchLabel = searchQuery ? `  · filter: '${searchQuery}'` : '';
+    const parts = [`${titleMap[type] || type}  ${countLabel}${pageLabel}${searchLabel}`, ''];
+    for (let i = 0; i < pageItems.length; i++) {
+      const item = pageItems[i];
+      const sel = i === localIdx;
+      const detail = buildItemDetail(type, item);
+      parts.push(sel ? `\x1b[1m\x1b[36m  ►  ${detail}` : `     ${detail}`);
+    }
+    // Pad to a fixed height so rerenderById always clears the same number of rows,
+    // regardless of how many items the current page has (last page may have fewer).
+    while (parts.length < PAGE_SIZE + 2) parts.push('');
+    return parts.join('\n');
+  }
+
+  function collapseListMsg(_type, _item) {
+    // Modal is transient — clearing it removes the picker from view; the
+    // selection's success line is emitted to scrollback by handlePendingSelection.
+    writer.clearModal();
+  }
+
+  function showPendingStep() {
+    if (!ctx.pendingAction) return;
+    const lines = buildListContent().split('\n');
+    const modalLines = lines.length > 0
+      ? [`  ${FG_GRAY}●${RST} ${FG_GRAY}${lines[0]}${RST}`].concat(lines.slice(1).map((l) => `    ${l}`))
+      : [];
+    writer.setModal(modalLines);
+  }
+
+  function finalizeListMsg() {
+    writer.clearModal();
+  }
+
+  function activateNavCapture() {
+    inputField.captureNavigation(async (action) => {
+      if (!ctx.pendingAction) { inputField.releaseNavigation(); return; }
+      const { items, displayItems: di, stepIdx } = ctx.pendingAction;
+      const activeItems = di || items;
+
+      if (action.startsWith('search:')) {
+        const query = action.slice(7);
+        if (!query) {
+          ctx.pendingAction = { ...ctx.pendingAction, displayItems: null, searchQuery: '', stepIdx: 0 };
+        } else {
+          const filtered = items.filter(item => getNavSearchText(ctx.pendingAction.type, item).toLowerCase().includes(query.toLowerCase()));
+          ctx.pendingAction = { ...ctx.pendingAction, displayItems: filtered, searchQuery: query, stepIdx: 0 };
+        }
+        showPendingStep();
+        return;
+      }
+
+      if (action === 'next') {
+        ctx.pendingAction = { ...ctx.pendingAction, stepIdx: activeItems.length ? (stepIdx + 1) % activeItems.length : 0 };
+        showPendingStep();
+      } else if (action === 'prev') {
+        ctx.pendingAction = { ...ctx.pendingAction, stepIdx: activeItems.length ? (stepIdx - 1 + activeItems.length) % activeItems.length : 0 };
+        showPendingStep();
+      } else if (action === 'select') {
+        if (!activeItems.length) return;
+        inputField.releaseNavigation();
+        const si = ctx.pendingAction.stepIdx;
+        collapseListMsg(ctx.pendingAction.type, activeItems[si]);
+        statusBar.update('idle');
+        await handlePendingSelection(si);
+        inputField.setDisabled(false);
+      } else if (action === 'cancel') {
+        inputField.releaseNavigation();
+        finalizeListMsg();
+        chatHistory.addMessage({ role: 'system', content: 'Cancelled.' });
+        ctx.pendingAction = null;
+        statusBar.update('idle');
+        inputField.setDisabled(false);
+      }
+    });
+  }
+
+  async function handlePendingSelection(idx) {
+    if (!ctx.pendingAction) return;
+    const { type, items, displayItems: di } = ctx.pendingAction;
+    const activeItems = di || items;
+    ctx.pendingAction = null;
+
+    if (type === 'history') {
+      const loaded = storage.load(activeItems[idx].id);
+      if (loaded) {
+        const filtered = (loaded.messages || []).filter((m) => m.role !== 'system');
+        const cleanup = cleanOrphanedToolMessages(filtered);
+        ctx.messages = cleanup.messages;
+        ctx.session = { id: loaded.id, created_at: loaded.created_at, model: loaded.model, messages: ctx.messages, stats: loaded.stats || { total_tokens: 0, duration_sec: 0 } };
+        ctx.currentChatId = null; ctx.savedUpTo = 0;
+        if (loaded.model && loaded.model !== ctx.currentModel) {
+          ctx.currentModel = loaded.model;
+          ctx.resolvedTokenLimit = await resolveTokenLimit(ctx.currentModel);
+          statusBar.setModel(ctx.currentModel);
+          statusBar.setContextLimit(ctx.resolvedTokenLimit);
+        }
+        displayLoadedMessages(ctx.messages);
+        chatHistory.addMessage({ role: 'system', content: `✓ Session loaded.  Model → ${ctx.currentModel}` });
+        emitCleanupWarning(cleanup);
+        seedContextFromMessages();
+      }
+    } else if (type === 'chats') {
+      const selectedChat = activeItems[idx];
+      try {
+        const chatData = await dashboardGetChat(selectedChat.id);
+        const loaded = chatData && chatData.messages ? chatData.messages : [];
+        const reconstructed = loaded.map(reconstructLoadedMessage);
+        const cleanup = cleanOrphanedToolMessages(reconstructed);
+        ctx.messages = cleanup.messages;
+        ctx.currentChatId = selectedChat.id; ctx.savedUpTo = ctx.messages.length;
+        displayLoadedMessages(loaded);
+        chatHistory.addMessage({ role: 'system', content: `✓ Resumed: ${selectedChat.title} (${loaded.length} messages)` });
+        emitCleanupWarning(cleanup);
+        seedContextFromMessages();
+      } catch (err) {
+        chatHistory.addMessage({ role: 'system', content: `✗ ${err.message}`, isError: true });
+      }
+    } else if (type === 'models') {
+      const selectedModel = activeItems[idx];
+      try {
+        const credResp = await dashboardGetModelForCli(selectedModel.id);
+        const model = credResp && credResp.model ? credResp.model : null;
+        if (!model) { chatHistory.addMessage({ role: 'system', content: '✗ Unable to load model.', isError: true }); return; }
+        const contextLength = (Number.isInteger(model.context_length) && model.context_length > 0 ? model.context_length : null)
+          || (Number.isInteger(model.max_tokens) && model.max_tokens > 0 ? model.max_tokens : null);
+        const config = getConfig();
+        const updated = { ...config, api_base: model.base_url, api_key: model.api_key, default_model: model.model_id, dashboard_model_id: model.id };
+        if (contextLength !== null) updated.context_length = contextLength;
+        setConfig(updated);
+        ctx.currentModel = model.model_id;
+        ctx.resolvedTokenLimit = await resolveTokenLimit(ctx.currentModel);
+        statusBar.setModel(ctx.currentModel);
+        statusBar.setContextLimit(ctx.resolvedTokenLimit);
+        ctx.currentChatId = null;
+        chatHistory.addMessage({ role: 'system', content: `✓ Model → ${model.name} (${model.model_id})` });
+        statusBar.update('idle');
+      } catch (err) {
+        chatHistory.addMessage({ role: 'system', content: `✗ ${err.message}`, isError: true });
+      }
+    }
+  }
+
+  return {
+    refreshInputSearchItems, saveSession, createChatIfNeeded, saveTurnToDashboard,
+    displayLoadedMessages, seedContextFromMessages, emitCleanupWarning,
+    getNavSearchText, buildItemDetail, buildListContent, collapseListMsg,
+    showPendingStep, finalizeListMsg, activateNavCapture, handlePendingSelection,
+  };
+}
+
+module.exports = { createChatSession };