feat: initialize desktop application with Tauri and Vite

- Added package.json for desktop package with scripts and dependencies.
- Created Cargo.toml for Tauri backend with necessary dependencies.
- Implemented build.rs for Tauri build process.
- Added icons for the application in various sizes and formats.
- Developed main.rs with server management commands and chat message handling.
- Configured tauri.conf.json for application settings and bundling.
- Created style.css for application styling.
- Set up Vite configuration for development server and build settings.

Author: rifkybujana

packages/cli/src/api/server.ts

@@ -104,6 +104,10 @@ async function handleGenerateOnce(
 
   try {
     const geminiClient = config.getGeminiClient();
+    
+    // Debug: Log available tools
+    console.error('[API] Available tools:', config.getExcludeTools());
+    console.error('[API] Approval mode:', config.getApprovalMode());
 
   const { processedQuery, shouldProceed } = await handleAtCommand({
     query: input,
@@ -260,6 +264,33 @@ export function startApiServer(
           {
             status: 'ok',
             timestamp: new Date().toISOString(),
+            mode: 'server',
+          },
+          enableCors,
+        );
+      }
+
+      if (url.pathname === '/status' && req.method === 'GET') {
+        if (!checkAuth(req, res, authToken, enableCors)) return;
+        
+        return sendJson(
+          res,
+          200,
+          {
+            status: 'ready',
+            timestamp: new Date().toISOString(),
+            version: '1.0.0', // TODO: Get from package.json
+            mode: 'server-only',
+            endpoints: {
+              generate: '/v1/generate',
+              health: '/healthz',
+              status: '/status'
+            },
+            features: {
+              streaming: true,
+              conversationHistory: true,
+              toolExecution: true
+            }
           },
           enableCors,
         );

packages/cli/src/config/config.ts

@@ -116,6 +116,10 @@ export interface CliArgs {
   tavilyApiKey: string | undefined;
   screenReader: boolean | undefined;
   vlmSwitchMode: string | undefined;
+  serverOnly: boolean | undefined;
+  noUiOutput: boolean | undefined;
+  apiPort: number | undefined;
+  apiHost: string | undefined;
 }
 
 export async function parseArguments(settings: Settings): Promise<CliArgs> {
@@ -290,6 +294,26 @@ export async function parseArguments(settings: Settings): Promise<CliArgs> {
             'Default behavior when images are detected in input. Values: once (one-time switch), session (switch for entire session), persist (continue with current model). Overrides settings files.',
           default: process.env['VLM_SWITCH_MODE'],
         })
+        .option('server-only', {
+          type: 'boolean',
+          description: 'Run in server-only mode (no interactive UI). Ideal for desktop app integration.',
+          default: false,
+        })
+        .option('no_ui_output', {
+          type: 'boolean',
+          description: 'Disable all UI output and run silently. Use with --server-only for headless operation.',
+          default: false,
+        })
+        .option('api-port', {
+          type: 'number',
+          description: 'Port for the API server to listen on.',
+          default: process.env['KOLOSAL_CLI_API_PORT'] ? Number(process.env['KOLOSAL_CLI_API_PORT']) : undefined,
+        })
+        .option('api-host', {
+          type: 'string',
+          description: 'Host for the API server to bind to.',
+          default: process.env['KOLOSAL_CLI_API_HOST'],
+        })
         .check((argv) => {
           if (argv.prompt && argv['promptInteractive']) {
             throw new Error(
@@ -495,8 +519,9 @@ export async function loadCliConfig(
   const interactive =
     !!argv.promptInteractive || (process.stdin.isTTY && question.length === 0);
   // In non-interactive mode, exclude tools that require a prompt.
+  // However, in server-only mode, we want to allow all tools for API access.
   const extraExcludes: string[] = [];
-  if (!interactive && !argv.experimentalAcp) {
+  if (!interactive && !argv.experimentalAcp && !argv.serverOnly) {
     switch (approvalMode) {
       case ApprovalMode.PLAN:
       case ApprovalMode.DEFAULT:

packages/cli/src/gemini.tsx

@@ -8,6 +8,7 @@ import { startServerIfEnabled, stopGlobalServer } from './server/kolosal-server-
 
 import type { Config } from '@kolosal-code/kolosal-code-core';
 import {
+  ApprovalMode,
   AuthType,
   FatalConfigError,
   getOauthClient,
@@ -229,6 +230,134 @@ export async function startInteractiveUI(
   registerCleanup(() => instance.unmount());
 }
 
+export async function startServerOnly(
+  config: Config,
+  settings: LoadedSettings,
+  workspaceRoot: string,
+): Promise<void> {
+  // Server-only mode - no UI, no interactive elements
+  // Skip UI initialization, theme loading, and desktop integration
+  // But keep essential authentication and client initialization
+  
+  // CRITICAL: Initialize the config - this sets up contentGeneratorConfig
+  await config.initialize();
+  
+  // Get authType from current model (needed for client initialization)
+  const { getCurrentModelAuthType, getSavedModelEntry } = await import('./config/savedModels.js');
+  const currentModelName = settings.merged.model?.name;
+  const savedModels = (settings.merged.model?.savedModels ?? []) as SavedModelEntry[];
+  const currentAuthType = getCurrentModelAuthType(currentModelName, savedModels);
+  const currentModelEntry = getSavedModelEntry(currentModelName, savedModels);
+  const hasStoredApiKey = Boolean(currentModelEntry?.apiKey?.trim());
+  const hasPersistedKolosalToken = Boolean(
+    typeof settings.merged.kolosalOAuthToken === 'string' &&
+      settings.merged.kolosalOAuthToken.trim(),
+  );
+  const usesOpenAICompatibleProvider = currentModelEntry?.provider === 'openai-compatible';
+
+  // Set approval mode to YOLO before creating the client to ensure all tools are available
+  const originalApprovalMode = config.getApprovalMode();
+  config.setApprovalMode(ApprovalMode.YOLO);
+  
+  // CRITICAL: Create the Gemini client by calling refreshAuth
+  // This is what actually creates this.geminiClient
+  try {
+    await config.refreshAuth(currentAuthType || AuthType.NO_AUTH);
+  } catch (err) {
+    if (config.getDebugMode()) {
+      console.error('[server-only] Client initialization failed:', err);
+    }
+    // Continue anyway - some operations might work without auth
+  }
+  
+  // Restore original approval mode after client creation
+  config.setApprovalMode(originalApprovalMode);
+
+  // Handle additional authentication if needed
+  const shouldPreAuthenticate =
+    currentAuthType === AuthType.USE_OPENAI &&
+    config.isBrowserLaunchSuppressed() &&
+    !hasStoredApiKey &&
+    !hasPersistedKolosalToken &&
+    !usesOpenAICompatibleProvider;
+
+  if (shouldPreAuthenticate) {
+    try {
+      await getOauthClient(currentAuthType, config);
+    } catch (err) {
+      if (config.getDebugMode()) {
+        console.error('[server-only] Authentication failed:', err);
+      }
+      // Continue anyway - some operations might work without auth
+    }
+  }
+
+  // Start kolosal-server in the background if enabled
+  const serverManager = await startServerIfEnabled({
+    debug: config.getDebugMode(),
+    autoStart: true,
+    port: 8087,
+  });
+
+  // Register cleanup to stop the server when CLI exits
+  if (serverManager) {
+    registerCleanup(async () => {
+      try {
+        await stopGlobalServer();
+      } catch (error) {
+        if (config.getDebugMode()) {
+          console.error('Error stopping kolosal-server:', error);
+        }
+      }
+    });
+  }
+
+  // Start API server with forced enabled state for server-only mode
+  try {
+    const { startApiServer } = await import('./api/server.js');
+    const port = Number(process.env['KOLOSAL_CLI_API_PORT'] ?? settings.merged.api?.port ?? 38080);
+    const host = process.env['KOLOSAL_CLI_API_HOST'] ?? settings.merged.api?.host ?? '127.0.0.1';
+    const authToken = process.env['KOLOSAL_CLI_API_TOKEN'] ?? settings.merged.api?.token;
+    
+    const apiServer = await startApiServer(config, {
+      port,
+      host,
+      enableCors: true, // Always enable CORS for desktop app
+      authToken,
+    });
+    
+    registerCleanup(async () => {
+      try { await apiServer.close(); } catch { /* ignore */ }
+    });
+    
+    // Always log debug info in server-only mode for troubleshooting
+    console.error(`[server-only] API server listening on http://${host}:${port}`);
+    console.error(`[server-only] Model: ${currentModelName}, Auth: ${currentAuthType}`);
+    console.error(`[server-only] Excluded tools:`, config.getExcludeTools());
+  } catch (e) {
+    console.error('Failed to start API server in server-only mode:', e);
+    throw e;
+  }
+
+  // Keep the process alive and handle graceful shutdown
+  const shutdown = async () => {
+    if (config.getDebugMode()) {
+      console.error('[server-only] Shutting down...');
+    }
+    await runExitCleanup();
+    process.exit(0);
+  };
+
+  process.once('SIGINT', shutdown);
+  process.once('SIGTERM', shutdown);
+  process.once('SIGUSR2', shutdown); // For nodemon
+
+  // Log startup completion only in debug mode
+  if (config.getDebugMode()) {
+    console.error(`[server-only] Kolosal CLI server ready on port ${process.env['KOLOSAL_CLI_API_PORT'] ?? 38080}`);
+  }
+}
+
 export async function main() {
   setupProcessExitHandlers();
   setupUnhandledRejectionHandler();
@@ -289,6 +418,21 @@ export async function main() {
 
   setMaxSizedBoxDebugging(config.getDebugMode());
 
+  // Check for server-only mode first (before config.initialize())
+  if (argv.serverOnly) {
+    // Override API settings for server-only mode
+    process.env['KOLOSAL_CLI_API'] = 'true'; // Force API enabled
+    if (argv.apiPort) {
+      process.env['KOLOSAL_CLI_API_PORT'] = argv.apiPort.toString();
+    }
+    if (argv.apiHost) {
+      process.env['KOLOSAL_CLI_API_HOST'] = argv.apiHost;
+    }
+    
+    await startServerOnly(config, settings, workspaceRoot);
+    return; // Exit early for server-only mode
+  }
+
   await config.initialize();
 
   // Optionally start lightweight HTTP API server to expose generation endpoints
@@ -301,8 +445,8 @@ export async function main() {
   if (apiEnabled) {
     try {
       const { startApiServer } = await import('./api/server.js');
-      const port = Number(process.env['KOLOSAL_CLI_API_PORT'] ?? settings.merged.api?.port ?? 38080);
-      const host = process.env['KOLOSAL_CLI_API_HOST'] ?? settings.merged.api?.host ?? '127.0.0.1';
+      const port = Number(argv.apiPort ?? process.env['KOLOSAL_CLI_API_PORT'] ?? settings.merged.api?.port ?? 38080);
+      const host = argv.apiHost ?? process.env['KOLOSAL_CLI_API_HOST'] ?? settings.merged.api?.host ?? '127.0.0.1';
       const authToken = process.env['KOLOSAL_CLI_API_TOKEN'] ?? settings.merged.api?.token;
       const corsEnabled = (process.env['KOLOSAL_CLI_API_CORS'] ?? '')
         ? ['1','true','yes'].includes(String(process.env['KOLOSAL_CLI_API_CORS']).toLowerCase())