omnikey-cli 1.0.15 → 1.0.17

package/README.md

@@ -6,6 +6,7 @@ A command-line tool for onboarding users to the Omnikey open-source app, configu
 
 OmnikeyAI is a productivity tool that helps you quickly rewrite selected text using your preferred LLM provider. The CLI allows you to configure and run the backend daemon on your local machine, manage your API keys, choose your LLM provider (OpenAI, Anthropic, or Gemini), and optionally configure the web search tool.
 
+- Website: [omnikeyai.ca](https://omnikeyai.ca)
 - For more details about the app and its features, see the [main README](https://github.com/GurinderRawala/OmniKey-AI).
 - Download the latest macOS app here: [Download OmniKeyAI for macOS](https://omnikeyai-saas-fmytqc3dra-uc.a.run.app/macos/download)
 - Download the latest Windows app here: [Download OmniKeyAI for Windows](https://omnikeyai-saas-fmytqc3dra-uc.a.run.app/windows/download)
@@ -33,16 +34,45 @@ omnikey daemon --port 7071
 # Kill the daemon
 omnikey kill-daemon
 
-# Remove the config directory and SQLite database (and persistence agent)
+# Restart the daemon (kill + start in one step)
+omnikey restart-daemon --port 7071
+
+# Show current configuration (API keys are masked)
+omnikey config
+
+# Set a single configuration value
+omnikey set OMNIKEY_PORT 8080
+
+# Remove the config directory (keeps SQLite database)
 omnikey remove-config
 
+# Remove config and also the SQLite database
+omnikey remove-config --db
+
 # Check daemon status
 omnikey status
 
 # Check daemon logs
 omnikey logs --lines 100
+
+# Check daemon error logs only
+omnikey logs --errors
 ```
 
+### Command reference
+
+| Command | Description |
+|---|---|
+| `omnikey onboard` | Interactive setup for LLM provider and web search |
+| `omnikey daemon [--port]` | Start the backend daemon (default port: 7071) |
+| `omnikey kill-daemon` | Stop the running daemon |
+| `omnikey restart-daemon [--port]` | Kill and restart the daemon |
+| `omnikey config` | Display current config with masked API keys |
+| `omnikey set <key> <value>` | Update a single config value |
+| `omnikey remove-config [--db]` | Remove config files; add `--db` to also delete the database |
+| `omnikey status` | Show what process is using the daemon port |
+| `omnikey logs [--lines N] [--errors]` | Tail daemon logs |
+
 ## Platform notes
 
 ### macOS

package/backend-dist/agent/agentPrompts.js

@@ -42,11 +42,17 @@ When you generate shell scripts, make them clear, efficient, and focused on gath
 - If there is a conflict, follow: system rules first, then stored instructions, then ad-hoc guidance in the current input.
 
 **Web tools:**
-You have access to web tools you can call at any time during a turn:
-- \`web_fetch(url)\`: Fetches the text content of any publicly accessible URL. Use it to retrieve documentation, error references, API guides, release notes, or any other web resource that would help answer the user's question.
-- \`web_search(query)\`: Searches the web and returns a list of relevant results (title, URL, snippet). Use it when you need to discover the right URL before fetching, or when a quick summary of search results is sufficient.
+You have access to web tools, but you must use them sparingly and only when explicitly required:
+- \`web_fetch(url)\`: Only call this when the user has provided a specific URL in their current input or stored instructions and you need to retrieve its contents.
+- \`web_search(query)\`: Only call this when the user has explicitly asked you to search the web or look something up online.
 
-Use these tools proactively whenever the question involves current information, external documentation, or anything not already available in the conversation or machine output. You may call web tools multiple times in a single turn; call \`web_fetch\` on a promising URL from \`web_search\` results to get full details. Web tool results are injected back into the conversation automatically; continue reasoning and then emit your shell script or final answer as normal.
+Do NOT use web tools proactively. Do NOT call them to look up documentation, error references, or general information you could infer from the machine output or your own knowledge. Your primary workflow is to generate shell scripts, wait for the terminal output, and reason from that output. Only reach for web tools when there is a clear, explicit instruction or a URL provided by the user.
+
+**User message tags:**
+User messages may be prefixed with special tags that indicate their origin:
+- \`TERMINAL OUTPUT:\` — the content is stdout/stderr returned from a previously requested \`<shell_script>\`. Parse it as machine output and use it to continue your reasoning toward a \`<final_answer>\` or a follow-up \`<shell_script>\`.
+- \`COMMAND ERROR:\` — the shell script failed or the terminal returned a non-zero exit code. Treat the content as error output: diagnose the failure, then either emit a corrected \`<shell_script>\` or explain the issue in a \`<final_answer>\`.
+- No prefix — the content is a direct message from the user; treat it as the primary request or question to address.
 
 **Interaction rules:**
 - When you need to execute ANY shell command, respond with a single \`<shell_script>\` block that contains the FULL script to run.

package/backend-dist/agent/agentServer.js

@@ -255,8 +255,13 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log) {
         let toolIterations = 0;
         while (result.finish_reason === 'tool_calls' && toolIterations < MAX_TOOL_ITERATIONS) {
             toolIterations++;
-            session.history.push(result.assistantMessage);
             const toolCalls = result.tool_calls ?? [];
+            // If the model claims tool_calls but sent none, treat it as a normal text
+            // response — pushing an assistant message with no following tool results
+            // would leave the history ending with an assistant turn, causing a 400.
+            if (!toolCalls.length)
+                break;
+            session.history.push(result.assistantMessage);
             log.info('Agent executing tool calls', {
                 sessionId,
                 turn: session.turns,
@@ -265,6 +270,18 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log) {
             });
             const toolResults = await Promise.all(toolCalls.map(async (tc) => {
                 const args = tc.arguments;
+                // Notify the frontend that a web tool call is about to execute.
+                const webCallContent = tc.name === 'web_search'
+                    ? `Searching the web for: "${args.query ?? ''}"`
+                    : `Fetching URL: ${args.url ?? ''}`;
+                send({
+                    session_id: sessionId,
+                    sender: 'agent',
+                    content: webCallContent,
+                    is_terminal_output: false,
+                    is_error: false,
+                    is_web_call: true,
+                });
                 const toolResult = await (0, web_search_provider_1.executeTool)(tc.name, args, log);
                 log.info('Tool call completed', {
                     sessionId,
@@ -287,10 +304,14 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log) {
             });
             await recordUsage(result);
         }
+        log.info('Finished reasoning and tool calls: ', {
+            reason: result.finish_reason,
+        });
+        const content = result.content.trim();
         // If the tool loop was exhausted while the model still wants more tool calls,
         // the last result has empty content. Force one final no-tools call so the model
         // must synthesize a text answer from everything gathered so far.
-        if (result.finish_reason === 'tool_calls') {
+        if (result.finish_reason === 'tool_calls' || !content) {
             log.warn('Tool iteration limit reached with pending tool calls; forcing final text response', {
                 sessionId,
                 turn: session.turns,
@@ -309,7 +330,6 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log) {
             });
             await recordUsage(result);
         }
-        const content = result.content.trim();
         if (!content) {
             log.warn('Agent LLM returned empty content; sending generic error to client.');
             const errorMessage = 'The agent returned an empty response. Please try again.';

package/backend-dist/index.js

@@ -19,19 +19,31 @@ const app = (0, express_1.default)();
 const PORT = Number(config_1.config.port);
 app.use((0, cors_1.default)());
 app.use(express_1.default.json());
+// Landing page
+app.use(express_1.default.static(path_1.default.join(process.cwd(), 'public')));
 app.use('/api/subscription', (0, subscriptionRoutes_1.createSubscriptionRouter)(logger_1.logger));
 app.use('/api/feature', (0, featureRoutes_1.createFeatureRouter)());
 app.use('/api/instructions', (0, taskInstructionRoutes_1.taskInstructionRouter)());
-app.get('/macos/download', (req, res) => {
+app.get('/macos/download', (_req, res) => {
     const dmgPath = path_1.default.join(process.cwd(), 'macOS', 'OmniKeyAI.dmg');
-    res.download(dmgPath, 'OmniKeyAI.dmg', (err) => {
-        if (err) {
-            logger_1.logger.error('Failed to send OmniKeyAI.dmg for download.', { error: err });
-            if (!res.headersSent) {
-                res.status(500).send('Unable to download file.');
-            }
+    if (!fs_1.default.existsSync(dmgPath)) {
+        res.status(404).send('File not found.');
+        return;
+    }
+    res.set({
+        'Content-Type': 'application/octet-stream',
+        'Content-Disposition': 'attachment; filename="OmniKeyAI.dmg"',
+        'Content-Encoding': 'gzip',
+    });
+    const fileStream = fs_1.default.createReadStream(dmgPath);
+    const gzip = zlib_1.default.createGzip();
+    fileStream.on('error', (err) => {
+        logger_1.logger.error('Failed to send OmniKeyAI.dmg for download.', { error: err });
+        if (!res.headersSent) {
+            res.status(500).send('Unable to download file.');
         }
     });
+    fileStream.pipe(gzip).pipe(res);
 });
 // Sparkle appcast feed for macOS updates.
 // This feed uses the existing /macos/download endpoint as the
@@ -52,8 +64,8 @@ app.get('/macos/appcast', (req, res) => {
     const appcastUrl = `${baseUrl}/macos/appcast`;
     // These should match the values embedded into the macOS app
     // Info.plist in macOS/build_release_dmg.sh.
-    const bundleVersion = '13';
-    const shortVersion = '1.0.12';
+    const bundleVersion = '14';
+    const shortVersion = '1.0.13';
     const xml = `<?xml version="1.0" encoding="utf-8"?>
 <rss version="2.0"
      xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle"
@@ -81,7 +93,7 @@ app.get('/macos/appcast', (req, res) => {
 // ── Windows distribution endpoints ───────────────────────────────────────────
 // These should match the values in windows/OmniKey.Windows.csproj
 // <Version> and windows/build_release_zip.ps1 $APP_VERSION.
-const WIN_VERSION = '1.1';
+const WIN_VERSION = '1.2';
 const WIN_ZIP_FILENAME = 'OmniKeyAI-windows-win-x64.zip';
 const WIN_ZIP_PATH = path_1.default.join(process.cwd(), 'windows', WIN_ZIP_FILENAME);
 // Serves the pre-built ZIP produced by windows/build_release_zip.ps1.
@@ -128,6 +140,9 @@ app.get('/windows/update', (req, res) => {
 app.get('/health', (_req, res) => {
     res.json({ status: 'ok' });
 });
+app.get('*', (_req, res) => {
+    res.sendFile(path_1.default.join(process.cwd(), 'public', 'index.html'));
+});
 let server = null;
 async function start() {
     try {

package/dist/daemon.js

@@ -68,8 +68,54 @@ function startDaemonWindows(opts) {
         console.error('Failed to write start-daemon.cmd:', e);
         return;
     }
-    // Register with Windows Task Scheduler so the daemon persists across reboots
+    // Register with Windows Task Scheduler so the daemon persists across reboots.
+    // Use XML-based registration to avoid cmd.exe quoting issues with paths containing spaces.
     const taskName = 'OmnikeyDaemon';
+    const username = process.env.USERNAME || process.env.USER || '';
+    // Escape characters that are special in XML
+    const xmlEscape = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+    const taskXml = `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>Omnikey API Backend Daemon</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>${xmlEscape(username)}</UserId>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>${xmlEscape(username)}</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <Hidden>true</Hidden>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>cmd.exe</Command>
+      <Arguments>/c &quot;${xmlEscape(wrapperPath)}&quot;</Arguments>
+      <WorkingDirectory>${xmlEscape(configDir)}</WorkingDirectory>
+    </Exec>
+  </Actions>
+</Task>`;
+    const taskXmlPath = path_1.default.join(configDir, 'task.xml');
+    try {
+        // Task Scheduler XML must be UTF-16 LE encoded
+        fs_1.default.writeFileSync(taskXmlPath, '\ufeff' + taskXml, 'utf16le');
+    }
+    catch (e) {
+        console.error('Failed to write task XML:', e);
+        return;
+    }
     try {
         // Delete existing task silently before creating a fresh one
         (0, child_process_2.execSync)(`schtasks /delete /tn "${taskName}" /f`, { stdio: 'pipe' });
@@ -78,13 +124,19 @@ function startDaemonWindows(opts) {
         // Task may not exist — that's fine
     }
     try {
-        (0, child_process_2.execSync)(`schtasks /create /tn "${taskName}" /tr "cmd /c \\"${wrapperPath}\\"" /sc ONLOGON /f`, { stdio: 'pipe' });
+        (0, child_process_2.execSync)(`schtasks /create /tn "${taskName}" /xml "${taskXmlPath}" /f`, { stdio: 'pipe' });
         console.log(`Windows Task Scheduler task created: ${taskName}`);
         console.log('Omnikey daemon will auto-start on next logon.');
     }
     catch (e) {
         console.error('Failed to create Windows Task Scheduler task:', e);
     }
+    finally {
+        try {
+            fs_1.default.rmSync(taskXmlPath);
+        }
+        catch { /* ignore */ }
+    }
     // Also start the backend immediately for the current session
     const { out, err } = (0, utils_1.initLogFiles)(logPath, errorLogPath);
     const child = (0, child_process_1.spawn)(nodePath, [backendPath], {

package/dist/index.js

@@ -8,6 +8,8 @@ const killDaemon_1 = require("./killDaemon");
 const removeConfig_1 = require("./removeConfig");
 const status_1 = require("./status");
 const showLogs_1 = require("./showLogs");
+const showConfig_1 = require("./showConfig");
+const setConfig_1 = require("./setConfig");
 const program = new commander_1.Command();
 program
     .name('omnikey')
@@ -56,4 +58,25 @@ program
     const errorsOnly = !!options.errors;
     (0, showLogs_1.showLogs)(lines, errorsOnly);
 });
+program
+    .command('config')
+    .description('Show the current Omnikey configuration (API keys are masked)')
+    .action(() => {
+    (0, showConfig_1.showConfig)();
+});
+program
+    .command('set <key> <value>')
+    .description('Set a single configuration key (e.g. omnikey set OMNIKEY_PORT 8080)')
+    .action((key, value) => {
+    (0, setConfig_1.setConfig)(key, value);
+});
+program
+    .command('restart-daemon')
+    .description('Restart the Omnikey API backend daemon')
+    .option('--port <port>', 'Port to run the backend on', '7071')
+    .action((options) => {
+    (0, killDaemon_1.killDaemon)();
+    const port = Number(options.port) || 7071;
+    (0, daemon_1.startDaemon)(port);
+});
 program.parseAsync(process.argv);

package/dist/removeConfig.js

@@ -117,14 +117,22 @@ function removeConfigAndDb(includeDb = false) {
     else {
         console.log('Skipping SQLite database removal (use --db to remove it).');
     }
-    // Remove .omnikey directory
+    // Remove all files/folders inside .omnikey except the SQLite database
     if (fs_1.default.existsSync(configDir)) {
         try {
-            fs_1.default.rmSync(configDir, { recursive: true, force: true });
-            console.log(`Removed config directory: ${configDir}`);
+            const entries = fs_1.default.readdirSync(configDir);
+            for (const entry of entries) {
+                if (entry.endsWith('.sqlite')) {
+                    continue;
+                }
+                const entryPath = path_1.default.join(configDir, entry);
+                fs_1.default.rmSync(entryPath, { recursive: true, force: true });
+                console.log(`Removed: ${entryPath}`);
+            }
+            console.log(`Cleared config directory (SQLite preserved): ${configDir}`);
         }
         catch (e) {
-            console.error(`Failed to remove config directory: ${e}`);
+            console.error(`Failed to clear config directory: ${e}`);
         }
     }
     else {

package/dist/setConfig.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setConfig = setConfig;
+const fs_1 = __importDefault(require("fs"));
+const utils_1 = require("./utils");
+function setConfig(key, value) {
+    const configDir = (0, utils_1.getConfigDir)();
+    const configPath = (0, utils_1.getConfigPath)();
+    if (!fs_1.default.existsSync(configDir)) {
+        fs_1.default.mkdirSync(configDir, { recursive: true });
+    }
+    const config = (0, utils_1.readConfig)();
+    config[key] = value;
+    fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+    console.log(`Set ${key} in ${configPath}`);
+}

package/dist/showConfig.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showConfig = showConfig;
+const fs_1 = __importDefault(require("fs"));
+const utils_1 = require("./utils");
+const API_KEY_FIELDS = [
+    'OPENAI_API_KEY',
+    'ANTHROPIC_API_KEY',
+    'GEMINI_API_KEY',
+    'SERPER_API_KEY',
+    'BRAVE_SEARCH_API_KEY',
+    'TAVILY_API_KEY',
+];
+function maskSecret(value) {
+    if (value.length <= 8)
+        return '****';
+    return value.slice(0, 4) + '****' + value.slice(-4);
+}
+function showConfig() {
+    const configPath = (0, utils_1.getConfigPath)();
+    const configDir = (0, utils_1.getConfigDir)();
+    if (!fs_1.default.existsSync(configPath)) {
+        console.log('No configuration found. Run `omnikey onboard` to get started.');
+        return;
+    }
+    const config = (0, utils_1.readConfig)();
+    const keys = Object.keys(config);
+    if (keys.length === 0) {
+        console.log('Configuration file exists but is empty.');
+        return;
+    }
+    console.log(`Config file: ${configPath}\n`);
+    console.log('Current configuration:');
+    console.log('─'.repeat(50));
+    for (const key of keys) {
+        const raw = String(config[key]);
+        const display = API_KEY_FIELDS.includes(key) ? maskSecret(raw) : raw;
+        console.log(`  ${key}: ${display}`);
+    }
+    console.log('─'.repeat(50));
+    console.log(`\nConfig directory: ${configDir}`);
+}

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "CLI for onboarding users to Omnikey AI and configuring OPENAI_API_KEY. Use Yarn for install/build.",
   "engines": {
     "node": ">=14.0.0",

package/src/daemon.ts

@@ -85,8 +85,54 @@ function startDaemonWindows(opts: DaemonOptions) {
     return;
   }
 
-  // Register with Windows Task Scheduler so the daemon persists across reboots
+  // Register with Windows Task Scheduler so the daemon persists across reboots.
+  // Use XML-based registration to avoid cmd.exe quoting issues with paths containing spaces.
   const taskName = 'OmnikeyDaemon';
+  const username = process.env.USERNAME || process.env.USER || '';
+  // Escape characters that are special in XML
+  const xmlEscape = (s: string) =>
+    s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+  const taskXml = `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>Omnikey API Backend Daemon</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>${xmlEscape(username)}</UserId>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>${xmlEscape(username)}</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <Hidden>true</Hidden>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>cmd.exe</Command>
+      <Arguments>/c &quot;${xmlEscape(wrapperPath)}&quot;</Arguments>
+      <WorkingDirectory>${xmlEscape(configDir)}</WorkingDirectory>
+    </Exec>
+  </Actions>
+</Task>`;
+  const taskXmlPath = path.join(configDir, 'task.xml');
+  try {
+    // Task Scheduler XML must be UTF-16 LE encoded
+    fs.writeFileSync(taskXmlPath, '\ufeff' + taskXml, 'utf16le');
+  } catch (e) {
+    console.error('Failed to write task XML:', e);
+    return;
+  }
   try {
     // Delete existing task silently before creating a fresh one
     execSync(`schtasks /delete /tn "${taskName}" /f`, { stdio: 'pipe' });
@@ -94,14 +140,13 @@ function startDaemonWindows(opts: DaemonOptions) {
     // Task may not exist — that's fine
   }
   try {
-    execSync(
-      `schtasks /create /tn "${taskName}" /tr "cmd /c \\"${wrapperPath}\\"" /sc ONLOGON /f`,
-      { stdio: 'pipe' },
-    );
+    execSync(`schtasks /create /tn "${taskName}" /xml "${taskXmlPath}" /f`, { stdio: 'pipe' });
     console.log(`Windows Task Scheduler task created: ${taskName}`);
     console.log('Omnikey daemon will auto-start on next logon.');
   } catch (e) {
     console.error('Failed to create Windows Task Scheduler task:', e);
+  } finally {
+    try { fs.rmSync(taskXmlPath); } catch { /* ignore */ }
   }
 
   // Also start the backend immediately for the current session

package/src/index.ts

@@ -7,6 +7,8 @@ import { killDaemon } from './killDaemon';
 import { removeConfigAndDb } from './removeConfig';
 import { statusCmd } from './status';
 import { showLogs } from './showLogs';
+import { showConfig } from './showConfig';
+import { setConfig } from './setConfig';
 
 const program = new Command();
 
@@ -64,4 +66,28 @@ program
     showLogs(lines, errorsOnly);
   });
 
+program
+  .command('config')
+  .description('Show the current Omnikey configuration (API keys are masked)')
+  .action(() => {
+    showConfig();
+  });
+
+program
+  .command('set <key> <value>')
+  .description('Set a single configuration key (e.g. omnikey set OMNIKEY_PORT 8080)')
+  .action((key: string, value: string) => {
+    setConfig(key, value);
+  });
+
+program
+  .command('restart-daemon')
+  .description('Restart the Omnikey API backend daemon')
+  .option('--port <port>', 'Port to run the backend on', '7071')
+  .action((options) => {
+    killDaemon();
+    const port = Number(options.port) || 7071;
+    startDaemon(port);
+  });
+
 program.parseAsync(process.argv);

package/src/removeConfig.ts

@@ -111,13 +111,21 @@ export function removeConfigAndDb(includeDb = false) {
     console.log('Skipping SQLite database removal (use --db to remove it).');
   }
 
-  // Remove .omnikey directory
+  // Remove all files/folders inside .omnikey except the SQLite database
   if (fs.existsSync(configDir)) {
     try {
-      fs.rmSync(configDir, { recursive: true, force: true });
-      console.log(`Removed config directory: ${configDir}`);
+      const entries = fs.readdirSync(configDir);
+      for (const entry of entries) {
+        if (entry.endsWith('.sqlite')) {
+          continue;
+        }
+        const entryPath = path.join(configDir, entry);
+        fs.rmSync(entryPath, { recursive: true, force: true });
+        console.log(`Removed: ${entryPath}`);
+      }
+      console.log(`Cleared config directory (SQLite preserved): ${configDir}`);
     } catch (e) {
-      console.error(`Failed to remove config directory: ${e}`);
+      console.error(`Failed to clear config directory: ${e}`);
     }
   } else {
     console.log(`Config directory does not exist: ${configDir}`);

package/src/setConfig.ts

@@ -0,0 +1,16 @@
+import fs from 'fs';
+import { readConfig, getConfigPath, getConfigDir } from './utils';
+
+export function setConfig(key: string, value: string) {
+  const configDir = getConfigDir();
+  const configPath = getConfigPath();
+
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+
+  const config = readConfig();
+  config[key] = value;
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+  console.log(`Set ${key} in ${configPath}`);
+}

package/src/showConfig.ts

@@ -0,0 +1,47 @@
+import fs from 'fs';
+import { readConfig, getConfigPath, getConfigDir } from './utils';
+
+const API_KEY_FIELDS = [
+  'OPENAI_API_KEY',
+  'ANTHROPIC_API_KEY',
+  'GEMINI_API_KEY',
+  'SERPER_API_KEY',
+  'BRAVE_SEARCH_API_KEY',
+  'TAVILY_API_KEY',
+];
+
+function maskSecret(value: string): string {
+  if (value.length <= 8) return '****';
+  return value.slice(0, 4) + '****' + value.slice(-4);
+}
+
+export function showConfig() {
+  const configPath = getConfigPath();
+  const configDir = getConfigDir();
+
+  if (!fs.existsSync(configPath)) {
+    console.log('No configuration found. Run `omnikey onboard` to get started.');
+    return;
+  }
+
+  const config = readConfig();
+  const keys = Object.keys(config);
+
+  if (keys.length === 0) {
+    console.log('Configuration file exists but is empty.');
+    return;
+  }
+
+  console.log(`Config file: ${configPath}\n`);
+  console.log('Current configuration:');
+  console.log('─'.repeat(50));
+
+  for (const key of keys) {
+    const raw = String(config[key]);
+    const display = API_KEY_FIELDS.includes(key) ? maskSecret(raw) : raw;
+    console.log(`  ${key}: ${display}`);
+  }
+
+  console.log('─'.repeat(50));
+  console.log(`\nConfig directory: ${configDir}`);
+}