diff --git a/packages/kbot/cat.jpg b/packages/kbot/cat.jpg new file mode 100644 index 00000000..afaaf577 Binary files /dev/null and b/packages/kbot/cat.jpg differ diff --git a/packages/kbot/dist-in/commands/images.js b/packages/kbot/dist-in/commands/images.js index 61d18556..20d49359 100644 --- a/packages/kbot/dist-in/commands/images.js +++ b/packages/kbot/dist-in/commands/images.js @@ -2,6 +2,7 @@ import { z } from 'zod'; import * as path from 'node:path'; import { sync as write } from '@polymech/fs/write'; import { sync as exists } from '@polymech/fs/exists'; +import { readFileSync } from 'node:fs'; import { isArray, isString } from '@polymech/core/primitives'; import { OptionsSchema } from '../zod_schema.js'; import { createImage, editImage } from '../lib/images-google.js'; @@ -59,32 +60,99 @@ export const ImageOptionsSchema = () => { }); }; async function launchGuiAndGetPrompt(argv) { + const logger = getLogger(argv); return new Promise((resolve, reject) => { const guiAppPath = getGuiAppPath(); console.log('guiAppPath', guiAppPath); if (!exists(guiAppPath)) { return reject(new Error(`GUI application not found at: ${guiAppPath}. Please build it first by running 'npm run tauri build' in 'gui/tauri-app'.`)); } + // Prepare CLI arguments const args = []; + // Add include files if (argv.include) { const includes = Array.isArray(argv.include) ? argv.include : [argv.include]; - // Resolve all paths to absolute paths before passing them to the GUI const absoluteIncludes = includes.map(p => path.resolve(p)); args.push(...absoluteIncludes); } - // Pass API key as argument (similar to how we pass include files) + // Add API key const config = loadConfig(argv); const apiKey = argv.api_key || config?.google?.key; if (apiKey) { args.push('--api-key', apiKey); } + // Add dst + if (argv.dst) { + args.push('--dst', argv.dst); + } + // Add prompt + if (argv.prompt) { + args.push('--prompt', argv.prompt); + } const tauriProcess = spawn(guiAppPath, args, { stdio: ['pipe', 'pipe', 'pipe'] }); let output = ''; let errorOutput = ''; tauriProcess.stdout.on('data', (data) => { const chunk = data.toString(); - console.log('GUI stdout chunk:', JSON.stringify(chunk)); - output += chunk; + // Check for config requests from the GUI + const lines = chunk.split('\n').filter(line => line.trim()); + for (const line of lines) { + try { + const message = JSON.parse(line); + if (message.type === 'config_request') { + logger.info('📨 Received config request from GUI'); + // Send config data back via Tauri commands + const config = loadConfig(argv); + const apiKey = argv.api_key || config?.google?.key; + const includes = argv.include ? (Array.isArray(argv.include) ? argv.include : [argv.include]) : []; + const absoluteIncludes = includes.map(p => path.resolve(p)); + // Send config via stdin (Tauri will call forward_config_to_frontend) + const configResponse = { + cmd: 'forward_config_to_frontend', + prompt: argv.prompt || null, + dst: argv.dst || null, + apiKey: apiKey || null, + files: absoluteIncludes + }; + tauriProcess.stdin?.write(JSON.stringify(configResponse) + '\n'); + logger.info('📤 Sent config response to GUI'); + // Send image data + for (const imagePath of absoluteIncludes) { + try { + if (exists(imagePath)) { + const imageBuffer = readFileSync(imagePath); + const base64 = imageBuffer.toString('base64'); + const mimeType = path.extname(imagePath).toLowerCase() === '.png' ? 'image/png' : 'image/jpeg'; + const filename = path.basename(imagePath); + // Verify base64 encoding + logger.info(`📸 Image encoding check: ${filename}`, { + bufferSize: imageBuffer.length, + base64Size: base64.length, + base64Sample: base64.substring(0, 50), + isValidBase64: /^[A-Za-z0-9+/]*={0,2}$/.test(base64) + }); + const imageResponse = { + cmd: 'forward_image_to_frontend', + base64, + mimeType, + filename + }; + tauriProcess.stdin?.write(JSON.stringify(imageResponse) + '\n'); + logger.info(`📤 Sent image data: ${filename} (${Math.round(base64.length / 1024)}KB)`); + } + } + catch (error) { + logger.error(`Failed to send image: ${imagePath}`, error.message); + } + } + } + } + catch (e) { + // Not a JSON message, add to regular output + console.log('GUI stdout chunk:', JSON.stringify(line)); + output += line + '\n'; + } + } }); tauriProcess.stderr.on('data', (data) => { const chunk = data.toString(); @@ -185,4 +253,4 @@ export const imageCommand = async (argv) => { logger.error('Failed to parse options or generate image:', error.message, error.issues, error.stack); } }; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"images.js","sourceRoot":"","sources":["../../src/commands/images.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,EAAE,IAAI,IAAI,KAAK,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,IAAI,IAAI,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAE9D,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,SAAS,aAAa;IAElB,sEAAsE;IACtE,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC;IAClE,oFAAoF;IACpF,MAAM,cAAc,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,IAAI,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC;QAC5E,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC;QACxB,CAAC,CAAC,SAAS,CAAC;IAEZ,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IAEjE,+DAA+D;IAC/D,IAAI,WAAmB,CAAC;IACxB,IAAI,cAAsB,CAAC;IAE3B,QAAQ,OAAO,CAAC,QAAQ,EAAE,CAAC;QACvB,KAAK,OAAO;YACR,WAAW,GAAG,QAAQ,CAAC;YACvB,cAAc,GAAG,eAAe,CAAC;YACjC,MAAM;QACV,KAAK,QAAQ;YACT,WAAW,GAAG,QAAQ,CAAC;YACvB,cAAc,GAAG,WAAW,CAAC;YAC7B,MAAM;QACV,KAAK,OAAO;YACR,WAAW,GAAG,UAAU,CAAC;YACzB,cAAc,GAAG,WAAW,CAAC;YAC7B,MAAM;QACV;YACI,MAAM,IAAI,KAAK,CAAC,yBAAyB,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IACrE,CAAC;IAED,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC;AACvE,CAAC;AAED,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,EAAE;IACnC,MAAM,UAAU,GAAG,aAAa,EAAE,CAAC,IAAI,CAAC;QACpC,MAAM,EAAE,IAAI;QACZ,OAAO,EAAE,IAAI;QACb,GAAG,EAAE,IAAI;QACT,KAAK,EAAE,IAAI;QACX,QAAQ,EAAE,IAAI;QACd,MAAM,EAAE,IAAI;QACZ,OAAO,EAAE,IAAI;QACb,GAAG,EAAE,IAAI;KACZ,CAAC,CAAC;IAEH,OAAO,UAAU,CAAC,MAAM,CAAC;QACrB,GAAG,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,0BAA0B,CAAC;QAChE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC,QAAQ,CAAC,+CAA+C,CAAC;QACrH,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,kDAAkD,CAAC;QAC5E,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,2CAA2C,CAAC;KACtF,CAAC,CAAC;AACP,CAAC,CAAA;AAED,KAAK,UAAU,qBAAqB,CAAC,IAAS;IAC1C,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACnC,MAAM,UAAU,GAAG,aAAa,EAAE,CAAC;QACnC,OAAO,CAAC,GAAG,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;QACtC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC;YACtB,OAAO,MAAM,CAAC,IAAI,KAAK,CAAC,iCAAiC,UAAU,8EAA8E,CAAC,CAAC,CAAC;QACxJ,CAAC;QACD,MAAM,IAAI,GAAa,EAAE,CAAC;QAC1B,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC7E,qEAAqE;YACrE,MAAM,gBAAgB,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5D,IAAI,CAAC,IAAI,CAAC,GAAG,gBAAgB,CAAC,CAAC;QACnC,CAAC;QAED,kEAAkE;QAClE,MAAM,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;QAChC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,IAAI,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC;QACnD,IAAI,MAAM,EAAE,CAAC;YACT,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;QACnC,CAAC;QAED,MAAM,YAAY,GAAG,KAAK,CAAC,UAAU,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;QAElF,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,IAAI,WAAW,GAAG,EAAE,CAAC;QAErB,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE;YACpC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC9B,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;YACxD,MAAM,IAAI,KAAK,CAAC;QACpB,CAAC,CAAC,CAAC;QAEH,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE;YACpC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC9B,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;YACxD,WAAW,IAAI,KAAK,CAAC;QACzB,CAAC,CAAC,CAAC;QAEH,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE;YAC9B,OAAO,CAAC,GAAG,CAAC,+BAA+B,EAAE,IAAI,CAAC,CAAC;YACnD,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;YACrD,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC;YAE1D,IAAI,IAAI,KAAK,CAAC,EAAE,CAAC;gBACb,MAAM,aAAa,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC;gBACpC,OAAO,CAAC,GAAG,CAAC,2BAA2B,EAAE,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC;gBACxE,OAAO,CAAC,aAAa,IAAI,IAAI,CAAC,CAAC;YACnC,CAAC;iBAAM,CAAC;gBACJ,MAAM,CAAC,IAAI,KAAK,CAAC,8BAA8B,IAAI,aAAa,WAAW,EAAE,CAAC,CAAC,CAAC;YACpF,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE;YAC7B,MAAM,CAAC,GAAG,CAAC,CAAC;QAChB,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;AACP,CAAC;AAGD,MAAM,CAAC,MAAM,YAAY,GAAG,KAAK,EAAE,IAAS,EAAE,EAAE;IAC5C,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAE/B,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;QACX,IAAI,CAAC;YACD,MAAM,SAAS,GAAG,MAAM,qBAAqB,CAAC,IAAI,CAAC,CAAC;YACpD,IAAI,SAAS,EAAE,CAAC;gBACZ,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;gBACtC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;gBAC7B,IAAI,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC5C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC;gBACjC,CAAC;gBACD,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;oBACd,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;gBAC3B,CAAC;YACL,CAAC;iBAAM,CAAC;gBACJ,MAAM,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;gBACtD,OAAO;YACX,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACb,MAAM,CAAC,KAAK,CAAC,oBAAoB,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;YAClD,OAAO;QACX,CAAC;IACL,CAAC;IAED,IAAI,IAAI,CAAC,OAAO,IAAI,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QACzC,IAAI,CAAC,OAAO,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAClC,CAAC;IAED,IAAI,CAAC;QACD,MAAM,aAAa,GAAG,kBAAkB,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACvD,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,aAAa,CAAC;QAEhD,MAAM,aAAa,GAAG,MAAM,aAAa,CAAC,aAAa,CAAC,CAAC;QACzD,MAAM,MAAM,GAAG,aAAa,EAAE,OAAiB,IAAI,EAAE,CAAC;QAEtD,IAAI,CAAC,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;YACtB,MAAM,CAAC,KAAK,CAAC,yFAAyF,CAAC,CAAC;YACxG,OAAO;QACX,CAAC;QAED,IAAI,CAAC,GAAG,EAAE,CAAC;YACP,MAAM,CAAC,KAAK,CAAC,oDAAoD,CAAC,CAAC;YACnE,OAAO;QACX,CAAC;QAED,IAAI,WAAW,GAAkB,IAAI,CAAC;QAEtC,IAAI,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpD,gBAAgB;YAChB,KAAK,MAAM,SAAS,IAAI,OAAO,EAAE,CAAC;gBAC9B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;oBACrB,MAAM,CAAC,KAAK,CAAC,6BAA6B,SAAS,EAAE,CAAC,CAAC;oBACvD,OAAO;gBACX,CAAC;YACL,CAAC;YACD,IAAI,CAAC,MAAM,EAAE,CAAC;gBACV,MAAM,CAAC,KAAK,CAAC,yCAAyC,CAAC,CAAC;gBACxD,OAAO;YACX,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,qBAAqB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,MAAM,GAAG,CAAC,CAAC;YACjF,WAAW,GAAG,MAAM,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC;QAClE,CAAC;aAAM,IAAI,MAAM,EAAE,CAAC;YAChB,iBAAiB;YACjB,MAAM,CAAC,IAAI,CAAC,gCAAgC,MAAM,GAAG,CAAC,CAAC;YACvD,WAAW,GAAG,MAAM,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;QAC3D,CAAC;QAED,IAAI,WAAW,EAAE,CAAC;YACd,MAAM,IAAI,GAAG,SAAS,CAAC,aAAa,CAAC,CAAC;YACtC,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;YACpE,KAAK,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;YAC5B,MAAM,CAAC,IAAI,CAAC,mBAAmB,OAAO,EAAE,CAAC,CAAC;QAC9C,CAAC;aAAM,CAAC;YACJ,MAAM,CAAC,KAAK,CAAC,2BAA2B,CAAC,CAAC;QAC9C,CAAC;IAEL,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC,4CAA4C,EAAE,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IACzG,CAAC;AACL,CAAC,CAAC"} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"images.js","sourceRoot":"","sources":["../../src/commands/images.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/kbot/dist-in/lib/ipc.d.ts b/packages/kbot/dist-in/lib/ipc.d.ts new file mode 100644 index 00000000..66efe8df --- /dev/null +++ b/packages/kbot/dist-in/lib/ipc.d.ts @@ -0,0 +1,57 @@ +export interface IPCMessage { + type: 'counter' | 'debug' | 'image' | 'prompt_submit' | 'error' | 'init_data' | 'gui_message'; + data: any; + timestamp?: number; + id?: string; +} +export interface ImagePayload { + base64: string; + mimeType: string; + filename?: string; +} +export interface PromptSubmitPayload { + prompt: string; + files: string[]; + dst: string; +} +export interface CounterPayload { + count: number; + message?: string; +} +export interface DebugPayload { + level: 'info' | 'warn' | 'error' | 'debug'; + message: string; + data?: any; +} +export interface InitDataPayload { + prompt?: string; + dst?: string; + apiKey?: string; + files?: string[]; +} +export interface GuiMessagePayload { + message: string; + timestamp: number; + source: string; +} +export declare class IPCClient { + private guiAppPath; + private process; + private messageHandlers; + private counter; + private isReady; + constructor(guiAppPath: string); + launch(args?: string[]): Promise; + private handleMessage; + onMessage(type: string, handler: (message: IPCMessage) => void): void; + sendMessage(message: IPCMessage): void; + sendDebugMessage(level: DebugPayload['level'], message: string, data?: any): void; + sendCounterMessage(count?: number, message?: string): void; + sendImageMessage(base64: string, mimeType: string, filename?: string): void; + sendInitData(prompt?: string, dst?: string, apiKey?: string, files?: string[]): void; + sendIPCViaTauri(messageType: string, data: any): Promise; + waitForPromptSubmit(): Promise; + close(): void; +} +export declare function getGuiAppPath(): string; +export declare function createIPCClient(): IPCClient; diff --git a/packages/kbot/dist-in/lib/ipc.js b/packages/kbot/dist-in/lib/ipc.js new file mode 100644 index 00000000..a4c1cf63 --- /dev/null +++ b/packages/kbot/dist-in/lib/ipc.js @@ -0,0 +1,238 @@ +import { spawn } from 'node:child_process'; +import * as path from 'node:path'; +import { sync as exists } from '@polymech/fs/exists'; +export class IPCClient { + guiAppPath; + process = null; + messageHandlers = new Map(); + counter = 0; + isReady = false; + constructor(guiAppPath) { + this.guiAppPath = guiAppPath; + } + async launch(args = []) { + return new Promise((resolve, reject) => { + if (!exists(this.guiAppPath)) { + return reject(new Error(`GUI application not found at: ${this.guiAppPath}`)); + } + this.process = spawn(this.guiAppPath, args, { + stdio: ['pipe', 'pipe', 'pipe'] + }); + let output = ''; + let errorOutput = ''; + this.process.stdout?.on('data', (data) => { + const chunk = data.toString(); + // Try to parse each line as a potential IPC message first + const lines = chunk.split('\n').filter(line => line.trim()); + let hasIPCMessage = false; + for (const line of lines) { + try { + const parsed = JSON.parse(line); + // Check if it's a structured IPC message + if (parsed.type && parsed.data !== undefined) { + this.handleMessage(parsed); + hasIPCMessage = true; + } + // Check if it's a raw GUI message (from console.log in browser mode) + else if (parsed.message && parsed.source === 'gui') { + const ipcMessage = { + type: 'gui_message', + data: parsed, + timestamp: parsed.timestamp || Date.now(), + id: `gui_${Date.now()}_${Math.random().toString(36).substr(2, 9)}` + }; + this.handleMessage(ipcMessage); + hasIPCMessage = true; + } + } + catch (e) { + // Not a JSON message, continue + } + } + // Only log non-IPC stdout (to avoid binary data spam) + if (!hasIPCMessage && chunk.trim() && !chunk.includes('"base64"')) { + console.log('[IPC] GUI stdout:', chunk); + } + // Also check for GUI messages in stdout + if (!hasIPCMessage && chunk.trim()) { + const lines = chunk.split('\n').filter(line => line.trim()); + for (const line of lines) { + try { + const possibleMessage = JSON.parse(line); + if (possibleMessage.type === 'gui_message') { + this.handleMessage(possibleMessage); + } + } + catch (e) { + // Not a JSON message, ignore + } + } + } + output += chunk; + }); + this.process.stderr?.on('data', (data) => { + const chunk = data.toString(); + console.log('[IPC] GUI stderr:', chunk); + errorOutput += chunk; + }); + this.process.on('close', (code) => { + console.log('[IPC] GUI process closed with code:', code); + if (code === 0) { + const trimmedOutput = output.trim(); + resolve(); + } + else { + reject(new Error(`Tauri app exited with code ${code}. stderr: ${errorOutput}`)); + } + }); + this.process.on('error', (err) => { + reject(err); + }); + // Give the process a moment to start + setTimeout(() => resolve(), 1000); + }); + } + handleMessage(message) { + // Create a safe version for logging (without binary data) + const safeMessage = { ...message }; + if (safeMessage.type === 'image' && safeMessage.data && typeof safeMessage.data === 'object' && 'base64' in safeMessage.data) { + safeMessage.data = { + ...safeMessage.data, + base64: `[BASE64 DATA - ${safeMessage.data.base64.length} chars]` + }; + } + console.log('[IPC] Received message:', safeMessage); + const handler = this.messageHandlers.get(message.type); + if (handler) { + handler(message); + } + else { + console.log('[IPC] No handler for message type:', message.type); + } + } + onMessage(type, handler) { + this.messageHandlers.set(type, handler); + } + sendMessage(message) { + if (!this.process || !this.process.stdin) { + console.error('[IPC] Cannot send message: process not available'); + return; + } + const messageWithMeta = { + ...message, + timestamp: Date.now(), + id: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}` + }; + const jsonMessage = JSON.stringify(messageWithMeta) + '\n'; + // Create a safe version for logging (without binary data) + const safeMessage = { ...messageWithMeta }; + if (safeMessage.type === 'image' && safeMessage.data && typeof safeMessage.data === 'object' && 'base64' in safeMessage.data) { + safeMessage.data = { + ...safeMessage.data, + base64: `[BASE64 DATA - ${safeMessage.data.base64.length} chars]` + }; + } + console.log('[IPC] Sending message:', JSON.stringify(safeMessage)); + this.process.stdin.write(jsonMessage); + } + sendDebugMessage(level, message, data) { + this.sendMessage({ + type: 'debug', + data: { level, message, data } + }); + } + sendCounterMessage(count, message) { + if (count === undefined) { + this.counter++; + count = this.counter; + } + this.sendMessage({ + type: 'counter', + data: { count, message } + }); + } + sendImageMessage(base64, mimeType, filename) { + this.sendMessage({ + type: 'image', + data: { base64, mimeType, filename } + }); + } + sendInitData(prompt, dst, apiKey, files) { + this.sendMessage({ + type: 'init_data', + data: { prompt, dst, apiKey, files } + }); + } + // Send IPC message via Tauri command (when GUI is ready) + async sendIPCViaTauri(messageType, data) { + if (!this.process) { + console.error('[IPC] Cannot send via Tauri: process not available'); + return; + } + // Send a special command to tell the GUI to forward this as an event + const command = { + type: 'tauri_command', + command: 'forward_ipc_message', + args: { messageType, data } + }; + const jsonMessage = JSON.stringify(command) + '\n'; + console.log('[IPC] Sending Tauri command:', JSON.stringify({ ...command, args: { messageType, data: messageType === 'image' ? '[IMAGE DATA]' : data } })); + this.process.stdin?.write(jsonMessage); + } + async waitForPromptSubmit() { + return new Promise((resolve) => { + this.onMessage('prompt_submit', (message) => { + resolve(message.data); + }); + // Also handle the legacy format for backwards compatibility + this.process?.on('close', (code) => { + if (code === 0) { + // Try to parse the final output as legacy format + // This will be handled by the existing logic in images.ts + resolve(null); + } + }); + }); + } + close() { + if (this.process) { + this.process.kill(); + this.process = null; + } + } +} +export function getGuiAppPath() { + // Get the directory of this script file, then navigate to the GUI app + const scriptDir = path.dirname(new URL(import.meta.url).pathname); + // On Windows, URL.pathname can have an extra leading slash, so we need to handle it + const cleanScriptDir = process.platform === 'win32' && scriptDir.startsWith('/') + ? scriptDir.substring(1) + : scriptDir; + const packageRoot = path.resolve(cleanScriptDir, '..', '..'); + // Determine platform-specific subdirectory and executable name + let platformDir; + let executableName; + switch (process.platform) { + case 'win32': + platformDir = 'win-64'; + executableName = 'tauri-app.exe'; + break; + case 'darwin': + platformDir = 'osx-64'; + executableName = 'tauri-app'; + break; + case 'linux': + platformDir = 'linux-64'; + executableName = 'tauri-app'; + break; + default: + throw new Error(`Unsupported platform: ${process.platform}`); + } + return path.join(packageRoot, 'dist', platformDir, executableName); +} +// Utility function to create and configure an IPC client +export function createIPCClient() { + const guiAppPath = getGuiAppPath(); + return new IPCClient(guiAppPath); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ipc.js","sourceRoot":"","sources":["../../src/lib/ipc.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/kbot/dist/win-64/tauri-app.exe b/packages/kbot/dist/win-64/tauri-app.exe index 72ab6cc2..e3d20340 100644 Binary files a/packages/kbot/dist/win-64/tauri-app.exe and b/packages/kbot/dist/win-64/tauri-app.exe differ diff --git a/packages/kbot/docs/ipc.md b/packages/kbot/docs/ipc.md new file mode 100644 index 00000000..bb693df3 --- /dev/null +++ b/packages/kbot/docs/ipc.md @@ -0,0 +1,235 @@ +# IPC Communication Documentation + +## Overview + +This document describes the Inter-Process Communication (IPC) system between the `images.ts` command and the Tauri GUI application. + +## Current Architecture + +### Components + +1. **images.ts** - Node.js CLI command process +2. **tauri-app.exe** - Tauri desktop application (Rust + Web frontend) +3. **IPC Client** - Node.js library for managing communication +4. **Tauri Commands** - Rust functions exposed to frontend +5. **React Frontend** - TypeScript/React UI + +## Communication Flows + +### 1. Initial Configuration Passing + +```mermaid +sequenceDiagram + participant CLI as images.ts CLI + participant IPC as IPC Client + participant Tauri as tauri-app.exe + participant Frontend as React Frontend + participant Rust as Tauri Rust Backend + + CLI->>IPC: createIPCClient() + CLI->>IPC: launch([]) + IPC->>Tauri: spawn tauri-app.exe + + Note over CLI,Rust: Initial data sending + CLI->>IPC: sendInitData(prompt, dst, apiKey, files) + IPC->>Tauri: stdout: {"type":"init_data","data":{...}} + Tauri->>Frontend: IPC message handling + Frontend->>Frontend: setPrompt(), setDst(), setApiKey() + + Note over CLI,Rust: Image data sending + CLI->>IPC: sendImageMessage(base64, mimeType, filename) + IPC->>Tauri: stdout: {"type":"image","data":{...}} + Tauri->>Frontend: IPC message handling + Frontend->>Frontend: addFiles([{path, src}]) +``` + +### 2. GUI to CLI Messaging (Current Implementation) + +```mermaid +sequenceDiagram + participant Frontend as React Frontend + participant Rust as Tauri Rust Backend + participant Tauri as tauri-app.exe + participant IPC as IPC Client + participant CLI as images.ts CLI + + Note over Frontend,CLI: User sends message from GUI + Frontend->>Frontend: sendMessageToImages() + Frontend->>Rust: safeInvoke('send_message_to_stdout', message) + Rust->>Rust: send_message_to_stdout command + Rust->>Tauri: println!(message) to stdout + Tauri->>IPC: stdout data received + IPC->>IPC: parse JSON from stdout + IPC->>CLI: handleMessage() callback + CLI->>CLI: gui_message handler + + Note over Frontend,CLI: Echo response + CLI->>IPC: sendDebugMessage('Echo: ...') + IPC->>Tauri: stdout: {"type":"debug","data":{...}} + Tauri->>Frontend: IPC message handling + Frontend->>Frontend: addDebugMessage() +``` + +### 3. Console Message Forwarding + +```mermaid +sequenceDiagram + participant Frontend as React Frontend + participant Console as Console Hijack + participant Rust as Tauri Rust Backend + participant CLI as images.ts CLI + + Note over Frontend,CLI: Console messages forwarding + Frontend->>Console: console.log/error/warn() + Console->>Console: hijacked in main.tsx + Console->>Rust: safeInvoke('log_error_to_console') + Rust->>Rust: log_error_to_console command + Rust->>CLI: eprintln! to stderr + CLI->>CLI: stderr logging +``` + +## Current Issues & Complexity + +### Problem 1: Multiple Communication Channels + +We have **3 different communication paths**: + +1. **IPC Messages** (structured): `{"type": "init_data", "data": {...}}` +2. **Raw GUI Messages** (via Tauri command): `{"message": "hello", "source": "gui"}` +3. **Console Forwarding** (via hijacking): All console.* calls + +### Problem 2: Inconsistent Message Formats + +- **From CLI to GUI**: Structured IPC messages +- **From GUI to CLI**: Raw JSON via stdout +- **Console logs**: String messages via stderr + +### Problem 3: Complex Parsing Logic + +The IPC client has to handle multiple message formats: + +```typescript +// Structured IPC message +if (parsed.type && parsed.data !== undefined) { + this.handleMessage(parsed as IPCMessage); +} +// Raw GUI message +else if (parsed.message && parsed.source === 'gui') { + const ipcMessage: IPCMessage = { + type: 'gui_message', + data: parsed, + // ... + }; + this.handleMessage(ipcMessage); +} +``` + +## Recommended Simplification + +### Option 1: Unified IPC Messages + +**All communication should use the same format:** + +```typescript +interface IPCMessage { + type: 'init_data' | 'gui_message' | 'debug' | 'image' | 'prompt_submit'; + data: any; + timestamp: number; + id: string; +} +``` + +**Sequence:** +```mermaid +sequenceDiagram + participant Frontend as React Frontend + participant Rust as Tauri Rust Backend + participant CLI as images.ts CLI + + Note over Frontend,CLI: Unified messaging + Frontend->>Rust: safeInvoke('send_ipc_message', {type, data}) + Rust->>CLI: stdout: {"type":"gui_message","data":{...},"timestamp":...} + CLI->>Rust: stdout: {"type":"debug","data":{...},"timestamp":...} + Rust->>Frontend: handleMessage(message) +``` + +### Option 2: Direct Tauri IPC (Recommended) + +**Use Tauri's built-in event system:** + +```mermaid +sequenceDiagram + participant Frontend as React Frontend + participant Rust as Tauri Rust Backend + participant CLI as images.ts CLI + + Note over Frontend,CLI: Tauri events + Frontend->>Rust: emit('gui-message', data) + Rust->>CLI: HTTP/WebSocket/Named Pipe + CLI->>Rust: HTTP/WebSocket/Named Pipe response + Rust->>Frontend: emit('cli-response', data) +``` + +## Current File Structure + +``` +src/ +├── lib/ipc.ts # IPC Client (Node.js side) +├── commands/images.ts # CLI command with IPC integration +gui/tauri-app/ +├── src/App.tsx # React frontend with IPC handling +├── src/main.tsx # Console hijacking setup +└── src-tauri/src/lib.rs # Tauri commands and state management +``` + +## Configuration Passing Methods + +### Method 1: CLI Arguments (Original) +```bash +tauri-app.exe --api-key "key" --dst "output.png" --prompt "text" file1.png file2.png +``` + +### Method 2: IPC Messages (Current) +```typescript +ipcClient.sendInitData(prompt, dst, apiKey, files); +``` + +### Method 3: Environment Variables +```bash +export API_KEY="key" +export DST="output.png" +tauri-app.exe +``` + +### Method 4: Temporary Config File +```typescript +// Write config.json +fs.writeFileSync('/tmp/config.json', JSON.stringify({prompt, dst, apiKey})); +// Launch app +spawn('tauri-app.exe', ['--config', '/tmp/config.json']); +``` + +## Recommendations + +1. **Simplify to single communication method** - Either all CLI args OR all IPC messages +2. **Remove console hijacking** - Use proper logging/debug channels +3. **Use consistent message format** - Same structure for all message types +4. **Consider Tauri's built-in IPC** - Events, commands, or invoke system +5. **Separate concerns** - Config passing vs. runtime messaging + +## Questions for Review + +1. Do we need bidirectional messaging during runtime, or just initial config passing? +2. Should console messages be forwarded, or use proper debug channels? +3. Is the complexity worth it, or should we use simpler CLI args + file output? +4. Could we use Tauri's built-in event system instead of stdout parsing? + +## Current Status + +- ✅ Config passing works (init_data messages) +- ✅ Image passing works (base64 via IPC) +- ✅ GUI → CLI messaging works (via Tauri command) +- ✅ CLI → GUI messaging works (debug messages) +- ❌ System is overly complex with multiple communication paths +- ❌ Inconsistent message formats +- ❌ Console hijacking adds unnecessary complexity diff --git a/packages/kbot/gui/tauri-app/ref/ProfileCard.tsx b/packages/kbot/gui/tauri-app/ref/ProfileCard.tsx new file mode 100644 index 00000000..a1b0b686 --- /dev/null +++ b/packages/kbot/gui/tauri-app/ref/ProfileCard.tsx @@ -0,0 +1,379 @@ +import React, { useState, useEffect, useMemo } from 'react'; +import { Card, CardContent, CardFooter, CardHeader, CardTitle } from '@/components/ui/card'; +import { Button } from '@/components/ui/button'; +import { Profile, PlotStatus, TemperatureProfileCommand } from '@/types'; +import BezierEditor from '@/components/profiles/bezier/BezierEditor'; +import { Edit, Trash2, Play, Pause, StopCircle, Copy, CopyPlus } from 'lucide-react'; +import { Switch } from "@/components/ui/switch"; +import { Label } from "@/components/ui/label"; +import { T, translate } from '../../i18n'; +import { useModbus } from '../../contexts/ModbusContext'; +import { getSlaveIdFromGroup, findCoilForProfile } from '../../lib/controllerUtils'; +import { PV_REGISTER_NAME_SUFFIX, PROFILE_REGISTER_NAMES } from '../../constants'; +import { useNavigate } from 'react-router-dom'; + +import { + Select, + SelectContent, + SelectItem, + SelectTrigger, + SelectValue, +} from '@/components/ui/select'; + +interface ProfileCardProps { + profile: Profile; + onDelete: (id: string) => void; + onCommand: (profileSlot: number, command: TemperatureProfileCommand) => void; + zones?: { id: string, name: string }[]; + onApplyToZone?: (profileId: string, zoneId: string) => void; + onDuplicate: (profileToDuplicate: Profile) => void; + onCopyTo: (profileToCopy: Profile) => void; + canDuplicate?: boolean; +} + +const formatDuration = (ms: number): string => { + if (isNaN(ms) || ms < 0) return '00h 00min 00s'; + const totalSeconds = Math.floor(ms / 1000); + const hours = Math.floor(totalSeconds / 3600); + const minutes = Math.floor((totalSeconds % 3600) / 60); + const seconds = totalSeconds % 60; + + // For durations less than 1 hour, show minutes and seconds + if (hours === 0) { + const paddedMinutes = minutes.toString().padStart(2, '0'); + const paddedSeconds = seconds.toString().padStart(2, '0'); + return `${paddedMinutes}min ${paddedSeconds}s`; + } + + // For durations 1+ hours, show hours and minutes + const paddedHours = hours.toString().padStart(2, '0'); + const paddedMinutes = minutes.toString().padStart(2, '0'); + return `${paddedHours}h ${paddedMinutes}min`; +}; + +// Helper function to get status text +const getStatusText = (status: PlotStatus): string => { + switch (status) { + case PlotStatus.IDLE: + return 'Idle'; + case PlotStatus.RUNNING: + return 'Running'; + case PlotStatus.INITIALIZING: + return 'Warmup'; + case PlotStatus.PAUSED: + return 'Paused'; + case PlotStatus.FINISHED: + return 'Finished'; + case PlotStatus.STOPPED: + return 'Stopped'; + default: + return 'Unknown'; + } +}; + +const ProfileCard: React.FC = ({ + profile, + onDelete, + onCommand, + zones, + onApplyToZone, + onDuplicate, + onCopyTo, + canDuplicate +}) => { + const navigate = useNavigate(); + const profileId = String(profile.slot); + const [plainTextDescription, setPlainTextDescription] = useState(''); + const { registers, settings, coils, updateCoil } = useModbus(); + const [isToggling, setIsToggling] = useState(false); + + const enableCoil = useMemo(() => { + if (!coils || !profile.name) return null; + return findCoilForProfile( + coils, + profile.name, + profile.slot, + PROFILE_REGISTER_NAMES.ENABLED + ); + }, [coils, profile.name, profile.slot]); + + const isEnabled = enableCoil ? enableCoil.value : false; + // console.log("isEnabled",profile.enabled,enableCoil); + + const handleToggle = async (newState: boolean) => { + if (!enableCoil) return; + setIsToggling(true); + try { + await updateCoil(enableCoil.address, newState); + } catch (error) { + console.error(`Failed to toggle profile ${profile.slot}`, error); + } finally { + setIsToggling(false); + } + }; + + // Create a name-to-slaveid map from the partition config + const controllerNameToSlaveIdMap = React.useMemo(() => { + const map = new Map(); + if (!settings) return map; + settings.partitions.forEach(partition => { + partition.controllers?.forEach(controller => { + if (controller.name) { + map.set(controller.name, controller.slaveid); + } + }); + }); + return map; + }, [settings]); + + const getControllerPv = (controllerName: string): number | string => { + const slaveid = controllerNameToSlaveIdMap.get(controllerName); + + if (slaveid === undefined) { + // Fallback or error for controllers not in the static config + // This might happen if profiles are associated with controllers not in PARTITION_CONFIG + const fallbackSlaveId = getSlaveIdFromGroup(controllerName); + if(fallbackSlaveId) { + // You can decide if you want to support this fallback. + // For now, let's just log a warning and return N/A if not in the map. + } + console.warn(`Could not determine slaveid for controller from settings: ${controllerName}`,controllerNameToSlaveIdMap); + return 'N/A'; + } + + const pvRegister = registers.find( + reg => getSlaveIdFromGroup(reg.group) === slaveid && reg.name.endsWith(PV_REGISTER_NAME_SUFFIX) + ); + + if (pvRegister && typeof pvRegister.value === 'number') { + return pvRegister.value.toFixed(1); + } else { + // It's possible for the register to exist but the value not be a number yet. + // Or for the register not to be found immediately. + console.error(`PV register not found for controller ${controllerName} (slaveid: ${slaveid})`); + } + + return 'N/A'; + }; + + useEffect(() => { + const getPlainTextFromMarkdown = async (markdown: string = '') => { + return markdown; + }; + + if (profile.description) { + getPlainTextFromMarkdown(profile.description); + } else { + setPlainTextDescription(''); + } + }, [profile.description]); + + return ( + + +
+ + {profile.name} + +
+
+ + +
+
+
+
+
+ {formatDuration(profile.duration)} Total +
+
+ {getStatusText(profile.status)} +
+
+ {profile.max}°C Max +
+ {(profile.status === PlotStatus.RUNNING || profile.status === PlotStatus.PAUSED || profile.status === PlotStatus.INITIALIZING) && ( + <> + {profile.currentTemp !== undefined && ( +
+ {profile.currentTemp}°C Now +
+ )} + {profile.elapsed !== undefined && ( +
+ {formatDuration(profile.elapsed)} Elapsed +
+ )} + {profile.remaining !== undefined && ( +
+ {formatDuration(profile.remaining)} Remaining +
+ )} + + + )} +
+
+ + + {plainTextDescription && ( +

+ {plainTextDescription} +

+ )} + + {profile.associatedControllerNames && profile.associatedControllerNames.length > 0 && ( +
+

{translate("Associated Controllers:")}

+
+ {profile.associatedControllerNames.map((name, index) => { + const slaveid = controllerNameToSlaveIdMap.get(name); + return ( +
+ {name}{slaveid !== undefined ? ` (${slaveid})` : ''}: + {getControllerPv(name)}°C +
+ ); + })} +
+
+ )} + +
+ {}} + max={profile.max} + duration={profile.duration} + readonly + showGridLabels={false} + className="h-40 w-full" + elapsedTime={profile.elapsed} + isRunning={profile.status === PlotStatus.RUNNING || profile.status === PlotStatus.PAUSED || profile.status === PlotStatus.INITIALIZING} + currentTemp={profile.currentTemp} + /> +
+ + {zones && zones.length > 0 && onApplyToZone && ( +
+

Apply to zone:

+ +
+ )} + + + + + {(profile.status === PlotStatus.IDLE || profile.status === PlotStatus.FINISHED || profile.status === PlotStatus.STOPPED) && ( + + )} + {(profile.status === PlotStatus.RUNNING || profile.status === PlotStatus.INITIALIZING) && ( + + )} + {profile.status === PlotStatus.PAUSED && ( + + )} + + {(profile.status === PlotStatus.RUNNING || profile.status === PlotStatus.PAUSED || profile.status === PlotStatus.INITIALIZING) && ( + + )} + + + + + + + + + ); +}; + +export default ProfileCard; diff --git a/packages/kbot/gui/tauri-app/src-tauri/Cargo.lock b/packages/kbot/gui/tauri-app/src-tauri/Cargo.lock index ab406ae9..ad02bcba 100644 --- a/packages/kbot/gui/tauri-app/src-tauri/Cargo.lock +++ b/packages/kbot/gui/tauri-app/src-tauri/Cargo.lock @@ -4046,6 +4046,7 @@ version = "0.1.0" dependencies = [ "dirs 5.0.1", "pathdiff", + "rand 0.8.5", "serde", "serde_json", "tauri", diff --git a/packages/kbot/gui/tauri-app/src-tauri/Cargo.toml b/packages/kbot/gui/tauri-app/src-tauri/Cargo.toml index 190ebb72..74ff5e8f 100644 --- a/packages/kbot/gui/tauri-app/src-tauri/Cargo.toml +++ b/packages/kbot/gui/tauri-app/src-tauri/Cargo.toml @@ -27,4 +27,5 @@ serde = { version = "1", features = ["derive"] } serde_json = "1" pathdiff = "0.2.3" dirs = "5.0.1" +rand = "0.8" diff --git a/packages/kbot/gui/tauri-app/src-tauri/src/lib.rs b/packages/kbot/gui/tauri-app/src-tauri/src/lib.rs index fffd0375..f08a5aad 100644 --- a/packages/kbot/gui/tauri-app/src-tauri/src/lib.rs +++ b/packages/kbot/gui/tauri-app/src-tauri/src/lib.rs @@ -1,9 +1,8 @@ -use tauri::Manager; +use tauri::{Manager, Emitter}; use serde::{Serialize, Deserialize}; -use dirs; -struct CliArgs(std::sync::Mutex>); -struct ApiKey(std::sync::Mutex>); +struct Counter(std::sync::Mutex); +struct DebugMessages(std::sync::Mutex>); #[derive(Serialize, Deserialize)] struct Payload { @@ -12,6 +11,36 @@ struct Payload { dst: String, } +#[derive(Serialize, Deserialize)] +struct IPCMessage { + #[serde(rename = "type")] + message_type: String, + data: serde_json::Value, + timestamp: Option, + id: Option, +} + +#[derive(Serialize, Deserialize)] +struct CounterPayload { + count: u32, + message: Option, +} + +#[derive(Serialize, Deserialize, Clone)] +struct DebugPayload { + level: String, + message: String, + data: Option, +} + +#[derive(Serialize, Deserialize)] +struct ImagePayload { + base64: String, + #[serde(rename = "mimeType")] + mime_type: String, + filename: Option, +} + // Learn more about Tauri commands at https://tauri.app/develop/calling-rust/ #[tauri::command] fn submit_prompt(prompt: &str, files: Vec, dst: &str, window: tauri::Window) { @@ -33,79 +62,321 @@ fn submit_prompt(prompt: &str, files: Vec, dst: &str, window: tauri::Win let _ = window.app_handle().exit(0); } -#[tauri::command] -fn get_cli_args(state: tauri::State<'_, CliArgs>) -> Result, String> { - eprintln!("[RUST LOG]: get_cli_args command called."); - let args = state.0.lock().unwrap().clone(); - eprintln!("[RUST LOG]: - Returning args: {:?}", args); - Ok(args) -} - -#[tauri::command] -fn resolve_path_relative_to_home(absolute_path: String) -> Result { - eprintln!("[RUST LOG]: resolve_path_relative_to_home command called."); - eprintln!("[RUST LOG]: - Received absolute path: {}", absolute_path); - - let home_dir = dirs::home_dir().ok_or_else(|| "Could not find home directory".to_string())?; - - let path_to_resolve = std::path::Path::new(&absolute_path); - - let relative_path = pathdiff::diff_paths(path_to_resolve, home_dir) - .ok_or_else(|| "Failed to calculate relative path from home directory".to_string())?; - - let result = relative_path.to_string_lossy().to_string(); - eprintln!("[RUST LOG]: - Resolved to path relative to home: {}", result); - Ok(result) -} - #[tauri::command] fn log_error_to_console(error: &str) { eprintln!("[WebView ERROR forwarded from JS]: {}", error); } #[tauri::command] -fn get_api_key(state: tauri::State<'_, ApiKey>) -> Result, String> { - eprintln!("[RUST LOG]: get_api_key command called."); - let api_key = state.0.lock().unwrap().clone(); - eprintln!("[RUST LOG]: - Returning API key: {:?}", api_key.is_some()); - Ok(api_key) +fn increment_counter(state: tauri::State<'_, Counter>) -> Result { + eprintln!("[RUST LOG]: increment_counter command called."); + let mut counter = state.0.lock().unwrap(); + *counter += 1; + let current_value = *counter; + eprintln!("[RUST LOG]: - Counter incremented to: {}", current_value); + Ok(current_value) +} + +#[tauri::command] +fn get_counter(state: tauri::State<'_, Counter>) -> Result { + eprintln!("[RUST LOG]: get_counter command called."); + let counter = state.0.lock().unwrap(); + let current_value = *counter; + eprintln!("[RUST LOG]: - Current counter value: {}", current_value); + Ok(current_value) +} + +#[tauri::command] +fn reset_counter(state: tauri::State<'_, Counter>) -> Result { + eprintln!("[RUST LOG]: reset_counter command called."); + let mut counter = state.0.lock().unwrap(); + *counter = 0; + eprintln!("[RUST LOG]: - Counter reset to: 0"); + Ok(0) +} + +#[tauri::command] +fn add_debug_message(message: String, level: String, data: Option, state: tauri::State<'_, DebugMessages>) -> Result<(), String> { + eprintln!("[RUST LOG]: add_debug_message command called."); + eprintln!("[RUST LOG]: - Level: {}", level); + eprintln!("[RUST LOG]: - Message: {}", message); + + let debug_payload = DebugPayload { + level, + message, + data, + }; + + let mut messages = state.0.lock().unwrap(); + messages.push(debug_payload); + + // Keep only the last 100 messages to prevent memory issues + if messages.len() > 100 { + let len = messages.len(); + messages.drain(0..len - 100); + } + + eprintln!("[RUST LOG]: - Debug message added. Total messages: {}", messages.len()); + Ok(()) +} + +#[tauri::command] +fn get_debug_messages(state: tauri::State<'_, DebugMessages>) -> Result, String> { + eprintln!("[RUST LOG]: get_debug_messages command called."); + let messages = state.0.lock().unwrap(); + let result = messages.clone(); + eprintln!("[RUST LOG]: - Returning {} debug messages", result.len()); + Ok(result) +} + +#[tauri::command] +fn clear_debug_messages(state: tauri::State<'_, DebugMessages>) -> Result<(), String> { + eprintln!("[RUST LOG]: clear_debug_messages command called."); + let mut messages = state.0.lock().unwrap(); + messages.clear(); + eprintln!("[RUST LOG]: - Debug messages cleared"); + Ok(()) +} + +#[tauri::command] +fn send_ipc_message(message_type: String, data: serde_json::Value, _window: tauri::Window) -> Result<(), String> { + eprintln!("[RUST LOG]: send_ipc_message command called."); + eprintln!("[RUST LOG]: - Type: {}", message_type); + eprintln!("[RUST LOG]: - Data: {}", data); + + let ipc_message = IPCMessage { + message_type, + data, + timestamp: Some(std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_millis() as u64), + id: Some(format!("msg_{}_{}", + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_millis(), + rand::random::())), + }; + + let json_message = serde_json::to_string(&ipc_message).unwrap(); + eprintln!("[RUST LOG]: - Sending IPC message to stdout: {}", json_message); + println!("{}", json_message); + + Ok(()) +} + +#[tauri::command] +fn send_message_to_stdout(message: String) -> Result<(), String> { + eprintln!("[RUST LOG]: send_message_to_stdout command called."); + eprintln!("[RUST LOG]: - Message: {}", message); + + // Send directly to stdout (this will be captured by images.ts) + println!("{}", message); + + Ok(()) +} + +#[tauri::command] +fn generate_image_via_backend(prompt: String, files: Vec, dst: String) -> Result<(), String> { + eprintln!("[RUST LOG]: generate_image_via_backend called"); + eprintln!("[RUST LOG]: - Prompt: {}", prompt); + eprintln!("[RUST LOG]: - Files: {:?}", files); + eprintln!("[RUST LOG]: - Dst: {}", dst); + + // Send generation request to images.ts via stdout + let request = serde_json::json!({ + "type": "generate_request", + "prompt": prompt, + "files": files, + "dst": dst, + "timestamp": std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_millis() + }); + + println!("{}", serde_json::to_string(&request).unwrap()); + eprintln!("[RUST LOG]: Generation request sent to images.ts"); + + Ok(()) +} + +#[tauri::command] +fn request_config_from_images(_app: tauri::AppHandle) -> Result<(), String> { + eprintln!("[RUST LOG]: request_config_from_images called"); + + // Send request to images.ts via stdout + let request = serde_json::json!({ + "type": "config_request", + "timestamp": std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_millis() + }); + + println!("{}", serde_json::to_string(&request).unwrap()); + eprintln!("[RUST LOG]: Config request sent to images.ts"); + + Ok(()) +} + +#[tauri::command] +fn forward_config_to_frontend(prompt: Option, dst: Option, api_key: Option, files: Vec, app: tauri::AppHandle) -> Result<(), String> { + eprintln!("[RUST LOG]: forward_config_to_frontend called"); + + let config_data = serde_json::json!({ + "prompt": prompt, + "dst": dst, + "apiKey": api_key, + "files": files + }); + + if let Err(e) = app.emit("config-received", &config_data) { + eprintln!("[RUST LOG]: Failed to emit config-received: {}", e); + return Err(format!("Failed to emit config: {}", e)); + } + + eprintln!("[RUST LOG]: Config forwarded to frontend successfully"); + Ok(()) +} + +#[tauri::command] +fn forward_image_to_frontend(base64: String, mime_type: String, filename: String, app: tauri::AppHandle) -> Result<(), String> { + eprintln!("[RUST LOG]: forward_image_to_frontend called for {}", filename); + + let image_data = serde_json::json!({ + "base64": base64, + "mimeType": mime_type, + "filename": filename + }); + + if let Err(e) = app.emit("image-received", &image_data) { + eprintln!("[RUST LOG]: Failed to emit image-received: {}", e); + return Err(format!("Failed to emit image: {}", e)); + } + + eprintln!("[RUST LOG]: Image forwarded to frontend successfully"); + Ok(()) } #[cfg_attr(mobile, tauri::mobile_entry_point)] pub fn run() { - let cli_args: Vec = std::env::args().skip(1).collect(); - - // Parse API key from CLI args (--api-key value) - let mut api_key = None; - let mut file_args = Vec::new(); - - let mut i = 0; - while i < cli_args.len() { - if cli_args[i] == "--api-key" && i + 1 < cli_args.len() { - api_key = Some(cli_args[i + 1].clone()); - i += 2; // Skip both --api-key and its value - } else { - file_args.push(cli_args[i].clone()); - i += 1; - } - } - - // Fallback to environment variables if not provided via CLI - if api_key.is_none() { - api_key = std::env::var("GOOGLE_API_KEY") - .or_else(|_| std::env::var("GEMINI_API_KEY")) - .or_else(|_| std::env::var("API_KEY")) - .ok(); - } - - tauri::Builder::default() - .manage(CliArgs(std::sync::Mutex::new(file_args))) - .manage(ApiKey(std::sync::Mutex::new(api_key))) + let app = tauri::Builder::default() + .manage(Counter(std::sync::Mutex::new(0))) + .manage(DebugMessages(std::sync::Mutex::new(Vec::new()))) .plugin(tauri_plugin_opener::init()) .plugin(tauri_plugin_dialog::init()) .plugin(tauri_plugin_fs::init()) .plugin(tauri_plugin_http::init()) - .invoke_handler(tauri::generate_handler![submit_prompt, log_error_to_console, get_cli_args, resolve_path_relative_to_home, get_api_key]) - .run(tauri::generate_context!()) - .expect("error while running tauri application"); + .invoke_handler(tauri::generate_handler![ + submit_prompt, + log_error_to_console, + increment_counter, + get_counter, + reset_counter, + add_debug_message, + get_debug_messages, + clear_debug_messages, + send_message_to_stdout, + send_ipc_message, + request_config_from_images, + forward_config_to_frontend, + forward_image_to_frontend + ]) + .setup(|app| { + let app_handle = app.handle().clone(); + + // Listen for stdin commands from images.ts + std::thread::spawn(move || { + use std::io::{self, BufRead, BufReader}; + let stdin = io::stdin(); + let reader = BufReader::new(stdin); + + eprintln!("[RUST LOG]: Stdin listener thread started"); + + for line in reader.lines() { + if let Ok(line_content) = line { + if line_content.trim().is_empty() { + continue; + } + + // Log stdin command but hide binary data + let log_content = if line_content.contains("\"base64\"") { + format!("[COMMAND WITH BASE64 DATA - {} chars]", line_content.len()) + } else { + line_content.clone() + }; + eprintln!("[RUST LOG]: Received stdin command: {}", log_content); + + // Parse command from images.ts + if let Ok(command) = serde_json::from_str::(&line_content) { + if let Some(cmd) = command.get("cmd").and_then(|v| v.as_str()) { + eprintln!("[RUST LOG]: Processing command: {}", cmd); + + match cmd { + "forward_config_to_frontend" => { + eprintln!("[RUST LOG]: Forwarding config to frontend"); + eprintln!("[RUST LOG]: - prompt: {:?}", command.get("prompt")); + eprintln!("[RUST LOG]: - dst: {:?}", command.get("dst")); + eprintln!("[RUST LOG]: - apiKey: {:?}", command.get("apiKey").map(|_| "[REDACTED]")); + eprintln!("[RUST LOG]: - files: {:?}", command.get("files")); + + let config_data = serde_json::json!({ + "prompt": command.get("prompt"), + "dst": command.get("dst"), + "apiKey": command.get("apiKey"), + "files": command.get("files") + }); + + if let Err(e) = app_handle.emit("config-received", &config_data) { + eprintln!("[RUST LOG]: Failed to emit config-received: {}", e); + } else { + eprintln!("[RUST LOG]: Config emitted successfully to frontend"); + } + } + "forward_image_to_frontend" => { + if let (Some(filename), Some(base64), Some(mime_type)) = ( + command.get("filename").and_then(|v| v.as_str()), + command.get("base64").and_then(|v| v.as_str()), + command.get("mimeType").and_then(|v| v.as_str()) + ) { + eprintln!("[RUST LOG]: Forwarding image to frontend: {}", filename); + let image_data = serde_json::json!({ + "base64": base64, + "mimeType": mime_type, + "filename": filename + }); + + if let Err(e) = app_handle.emit("image-received", &image_data) { + eprintln!("[RUST LOG]: Failed to emit image-received: {}", e); + } else { + eprintln!("[RUST LOG]: Image emitted successfully: {}", filename); + } + } + } + _ => { + eprintln!("[RUST LOG]: Unknown command: {}", cmd); + } + } + } + } else { + eprintln!("[RUST LOG]: Failed to parse command as JSON"); + } + } + } + eprintln!("[RUST LOG]: Stdin listener thread ended"); + }); + + Ok(()) + }) + .build(tauri::generate_context!()) + .expect("error while building tauri application"); + + app.run(|_app_handle, event| match event { + tauri::RunEvent::ExitRequested { api, .. } => { + api.prevent_exit(); + } + _ => {} + }); } diff --git a/packages/kbot/gui/tauri-app/src/App.tsx b/packages/kbot/gui/tauri-app/src/App.tsx index 7709b510..16506625 100644 --- a/packages/kbot/gui/tauri-app/src/App.tsx +++ b/packages/kbot/gui/tauri-app/src/App.tsx @@ -1,8 +1,72 @@ import { useState, useEffect } from "react"; -import { invoke } from "@tauri-apps/api/core"; -import { open, save } from '@tauri-apps/plugin-dialog'; -import { readFile, writeFile, BaseDirectory } from '@tauri-apps/plugin-fs'; -import { fetch } from '@tauri-apps/plugin-http'; + +let invoke: any, open: any, save: any, readFile: any, writeFile: any, BaseDirectory: any, fetch: any, listen: any, getCurrentWindow: any; +let isTauri = false; + +// Detect Tauri environment by trying to import getCurrentWindow +import("@tauri-apps/api/window").then(module => { + getCurrentWindow = module.getCurrentWindow; + isTauri = true; + console.log('✅ Tauri window API loaded - running in Tauri environment'); +}).catch(() => { + console.log('🌐 Tauri window API not available - running in browser mode'); + isTauri = false; +}); + +// Load other Tauri APIs +import("@tauri-apps/api/core").then(module => { + invoke = module.invoke; + console.log('✅ Tauri core API loaded'); +}).catch(() => { + console.log('❌ Tauri core API not available'); +}); + +import("@tauri-apps/api/event").then(module => { + listen = module.listen; + console.log('✅ Tauri event API loaded'); +}).catch(() => { + console.log('❌ Tauri event API not available'); +}); + +import("@tauri-apps/plugin-dialog").then(module => { + open = module.open; + save = module.save; + console.log('✅ Tauri dialog plugin loaded'); +}).catch(() => { + console.log('❌ Tauri dialog plugin not available'); +}); + +import("@tauri-apps/plugin-fs").then(module => { + readFile = module.readFile; + writeFile = module.writeFile; + BaseDirectory = module.BaseDirectory; + console.log('✅ Tauri fs plugin loaded'); +}).catch(() => { + console.log('❌ Tauri fs plugin not available'); +}); + +import("@tauri-apps/plugin-http").then(module => { + fetch = module.fetch; + console.log('✅ Tauri http plugin loaded'); +}).catch(() => { + console.log('❌ Tauri http plugin not available'); + fetch = window.fetch; // Browser fallback +}); + +// Browser fallback +if (typeof window !== 'undefined' && !fetch) { + fetch = window.fetch; +} + +// Safe invoke function that works in both Tauri and browser environments +const safeInvoke = (command: string, args?: any) => { + if (invoke) { + return invoke(command, args); + } else { + console.log(`[Browser Mode] Would invoke: ${command}`, args); + return Promise.resolve(null); + } +}; // Path imports commented out since they're not currently used // import { // homeDir, audioDir, cacheDir, configDir, dataDir, localDataDir, desktopDir, @@ -43,6 +107,12 @@ function App() { const [generatedImages, setGeneratedImages] = useState([]); const [isGenerating, setIsGenerating] = useState(false); const [apiKey, setApiKey] = useState(""); + const [isDarkMode, setIsDarkMode] = useState(false); + const [counter, setCounter] = useState(0); + const [debugMessages, setDebugMessages] = useState([]); + const [showDebugPanel, setShowDebugPanel] = useState(true); // Default open for debugging + const [ipcInitialized, setIpcInitialized] = useState(false); + const [messageToSend, setMessageToSend] = useState(""); const generateDefaultDst = (fileCount: number, firstFilePath?: string) => { if (fileCount === 1 && firstFilePath) { @@ -58,27 +128,60 @@ function App() { }; const addFiles = async (newPaths: string[]) => { + if (!isTauri) { + console.log('[Browser Mode] File operations not available'); + return; + } + + // Wait for Tauri APIs to be loaded + let attempts = 0; + while ((!readFile || !BaseDirectory) && attempts < 50) { + await new Promise(resolve => setTimeout(resolve, 100)); + attempts++; + } + + if (!readFile || !BaseDirectory) { + console.error('Tauri APIs not loaded after 5 seconds, cannot process files'); + return; + } + const uniqueNewPaths = newPaths.filter(newPath => !files.some(f => f.path === newPath)); const newImageFiles: ImageFile[] = []; - console.log('uniqueNewPaths', uniqueNewPaths); + console.log('Processing uniqueNewPaths:', uniqueNewPaths); + for (const path of uniqueNewPaths) { try { + console.log('Processing path:', path); + // Ask Rust to make the path relative to the HOME directory - console.log('path', path); - const relativePath = await invoke('resolve_path_relative_to_home', { absolutePath: path }); + const relativePath = await safeInvoke('resolve_path_relative_to_home', { absolutePath: path }) as string; + console.log('Relative path resolved:', relativePath); + + if (!relativePath) { + console.warn(`Could not resolve relative path for: ${path}`); + continue; + } + const buffer = await readFile(relativePath, { baseDir: BaseDirectory.Home }); + console.log('File read successfully, buffer size:', buffer.length); + const base64 = arrayBufferToBase64(Array.from(buffer)); - //const mimeType = lookup(path) || 'image/png'; - const mimeType = 'image/png'; + const mimeType = path.toLowerCase().endsWith('.png') ? 'image/png' : + path.toLowerCase().endsWith('.jpg') || path.toLowerCase().endsWith('.jpeg') ? 'image/jpeg' : + 'image/png'; // default const src = `data:${mimeType};base64,${base64}`; + newImageFiles.push({ path, src }); + console.log('Successfully processed file:', path); } catch (e) { const errorMessage = e instanceof Error ? e.message : JSON.stringify(e); console.error(`Failed to read file: ${path}`, e); - invoke('log_error_to_console', { error: `[Frontend Error] Failed to read file ${path}: ${errorMessage}` }); + safeInvoke('log_error_to_console', { error: `[Frontend Error] Failed to read file ${path}: ${errorMessage}` }); } } + + console.log('Adding files to state:', newImageFiles.length); setFiles(prevFiles => [...prevFiles, ...newImageFiles]); }; @@ -183,35 +286,208 @@ function App() { toString: error?.toString() || 'No string representation' }; console.error('Error details:', errorDetails); - invoke('log_error_to_console', { error: `[Frontend Error] Image generation failed: ${JSON.stringify(errorDetails)}` }); + safeInvoke('log_error_to_console', { error: `[Frontend Error] Image generation failed: ${JSON.stringify(errorDetails)}` }); } finally { setIsGenerating(false); } }; + // Theme management useEffect(() => { - const fetchCliArgs = async () => { - try { - const cliFiles = await invoke('get_cli_args'); - if (cliFiles && cliFiles.length > 0) { - addFiles(cliFiles); - } - - // Try to get API key from CLI environment or args - try { - const key = await invoke('get_api_key'); - if (key) { - setApiKey(key); - setChatMode(true); // Enable chat mode if API key is available - } - } catch (e) { - console.log("No API key provided, using simple mode"); - } - } catch (e) { - console.error("Failed to get CLI arguments:", e); + // Load theme from localStorage + const savedTheme = localStorage.getItem('theme'); + if (savedTheme === 'dark') { + setIsDarkMode(true); + document.documentElement.classList.add('dark'); + } else if (savedTheme === 'light') { + setIsDarkMode(false); + document.documentElement.classList.remove('dark'); + } else { + // Default to system preference + const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches; + setIsDarkMode(prefersDark); + if (prefersDark) { + document.documentElement.classList.add('dark'); } + } + }, []); + + const toggleTheme = () => { + const newDarkMode = !isDarkMode; + setIsDarkMode(newDarkMode); + + if (newDarkMode) { + document.documentElement.classList.add('dark'); + localStorage.setItem('theme', 'dark'); + } else { + document.documentElement.classList.remove('dark'); + localStorage.setItem('theme', 'light'); + } + }; + + useEffect(() => { + const initializeApp = async () => { + console.log('Initializing app...'); + console.log('isTauri:', isTauri); + + // Wait for Tauri APIs to be loaded first (check if any loaded) + let attempts = 0; + while (!invoke && attempts < 50) { + await new Promise(resolve => setTimeout(resolve, 100)); + attempts++; + } + + // Update isTauri based on whether APIs actually loaded + const actuallyInTauri = !!invoke; + console.log('Environment detection result:', { + initialDetection: isTauri, + actuallyInTauri, + invokeLoaded: !!invoke, + listenLoaded: !!listen + }); + + if (actuallyInTauri) { + + // Initialize counter from backend + try { + await getCounter(); + addDebugMessage('info', 'IPC system initialized successfully'); + } catch (e) { + console.log("Failed to initialize counter:", e); + addDebugMessage('warn', 'Counter initialization failed - running in browser mode'); + } + + } + + // Set up Tauri event listeners for config and images + const setupTauriEventListeners = async () => { + if (actuallyInTauri && listen) { + try { + console.log('Setting up Tauri event listeners'); + + // Listen for config data + await listen('config-received', (event: any) => { + console.log('Received config event:', event); + const data = event.payload; + + console.log('Config data details:', { + prompt: data.prompt, + dst: data.dst, + apiKey: data.apiKey ? '[REDACTED]' : null, + files: data.files + }); + + if (data.prompt) { + console.log('Setting prompt from config:', data.prompt); + setPrompt(data.prompt); + } else { + console.log('No prompt in config data'); + } + + if (data.dst) { + console.log('Setting dst from config:', data.dst); + setDst(data.dst); + } else { + console.log('No dst in config data'); + } + + if (data.apiKey) { + console.log('Setting API key from config'); + setApiKey(data.apiKey); + setChatMode(true); + } else { + console.log('No API key in config data'); + } + + setIpcInitialized(true); + addDebugMessage('info', '📨 Config received from images.ts', { + hasPrompt: !!data.prompt, + hasDst: !!data.dst, + hasApiKey: !!data.apiKey, + fileCount: data.files?.length || 0 + }); + }); + + // Listen for image data + await listen('image-received', (event: any) => { + const imageData = event.payload; + + addDebugMessage('debug', '🖼️ Processing image data', { + filename: imageData.filename, + mimeType: imageData.mimeType, + base64Length: imageData.base64?.length, + base64Sample: imageData.base64?.substring(0, 50) + '...', + hasValidData: !!(imageData.base64 && imageData.mimeType && imageData.filename) + }); + + if (imageData.base64 && imageData.mimeType && imageData.filename) { + const src = `data:${imageData.mimeType};base64,${imageData.base64}`; + + // Test if the base64 is valid by trying to create an image + const testImg = new Image(); + testImg.onload = () => { + addDebugMessage('info', `✅ Image loaded successfully: ${imageData.filename}`); + }; + testImg.onerror = () => { + addDebugMessage('error', `❌ Failed to load image: ${imageData.filename}`, { + mimeType: imageData.mimeType, + base64Start: imageData.base64.substring(0, 100) + }); + }; + testImg.src = src; + + const newImageFile = { path: imageData.filename, src }; + setFiles(prevFiles => { + const exists = prevFiles.some(f => f.path === imageData.filename); + if (!exists) { + addDebugMessage('info', `📁 Adding image to files: ${imageData.filename}`); + return [...prevFiles, newImageFile]; + } + addDebugMessage('warn', `🔄 Image already exists: ${imageData.filename}`); + return prevFiles; + }); + + addDebugMessage('info', '📨 Image received from images.ts', { + filename: imageData.filename, + mimeType: imageData.mimeType, + size: `${Math.round(imageData.base64.length/1024)}KB` + }); + } else { + addDebugMessage('error', '❌ Invalid image data received', { + hasBase64: !!imageData.base64, + hasMimeType: !!imageData.mimeType, + hasFilename: !!imageData.filename + }); + } + }); + + addDebugMessage('info', 'Tauri event listeners set up'); + + // NOW request config from images.ts (after listeners are ready) + try { + console.log('Requesting config from images.ts...'); + await safeInvoke('request_config_from_images'); + addDebugMessage('info', 'Config request sent to images.ts'); + } catch (e) { + console.error('Failed to request config:', e); + addDebugMessage('error', `Failed to request config: ${e}`); + } + + } catch (error) { + console.error('Failed to set up Tauri event listeners:', error); + addDebugMessage('error', `Failed to set up event listeners: ${error}`); + } + } else { + addDebugMessage('warn', 'Tauri event listeners not available - running in browser mode'); + } + }; + + // Set up event listeners with delay to ensure listen function is loaded + setTimeout(setupTauriEventListeners, 500); }; - fetchCliArgs(); + + // Delay the initialization slightly to ensure everything is loaded + setTimeout(initializeApp, 200); }, []); // Auto-generate default destination file when files change @@ -271,17 +547,160 @@ function App() { } else { // Simple mode: send to CLI try { - const result = await invoke("submit_prompt", { prompt, files: files.map(f => f.path), dst }); + const result = await safeInvoke("submit_prompt", { prompt, files: files.map(f => f.path), dst }); console.log('Submit result:', result); } catch (error) { console.error('Submit error:', error); - invoke('log_error_to_console', { error: `[Frontend Error] Submit failed: ${JSON.stringify(error)}` }); + safeInvoke('log_error_to_console', { error: `[Frontend Error] Submit failed: ${JSON.stringify(error)}` }); } } } - const saveGeneratedImage = async (generatedImage: GeneratedImage) => { + // Counter functions + const incrementCounter = async () => { + if (!isTauri) { + setCounter(prev => prev + 1); + return; + } + try { + const newCount = await safeInvoke('increment_counter') as number; + setCounter(newCount); + addDebugMessage('info', `Counter incremented to ${newCount}`); + } catch (error) { + console.error('Failed to increment counter:', error); + addDebugMessage('error', `Failed to increment counter: ${error}`); + } + }; + + const resetCounter = async () => { + if (!isTauri) { + setCounter(0); + return; + } + + try { + await safeInvoke('reset_counter'); + setCounter(0); + addDebugMessage('info', 'Counter reset to 0'); + } catch (error) { + console.error('Failed to reset counter:', error); + addDebugMessage('error', `Failed to reset counter: ${error}`); + } + }; + + const getCounter = async () => { + if (!isTauri) return; + + try { + const currentCount = await safeInvoke('get_counter') as number; + setCounter(currentCount); + addDebugMessage('info', `Current counter value: ${currentCount}`); + } catch (error) { + console.error('Failed to get counter:', error); + addDebugMessage('error', `Failed to get counter: ${error}`); + } + }; + + // Debug message functions + const addDebugMessage = async (level: 'info' | 'warn' | 'error' | 'debug', message: string, data?: any) => { + const timestamp = new Date().toLocaleTimeString(); + const debugMsg = { level, message, data, timestamp }; + + // Add to local state + setDebugMessages(prev => [...prev.slice(-99), debugMsg]); // Keep last 100 messages + + if (!isTauri) return; + + try { + await safeInvoke('add_debug_message', { message, level, data }); + } catch (error) { + console.error('Failed to add debug message:', error); + } + }; + + const clearDebugMessages = async () => { + setDebugMessages([]); + + if (!isTauri) return; + + try { + await safeInvoke('clear_debug_messages'); + addDebugMessage('info', 'Debug messages cleared'); + } catch (error) { + console.error('Failed to clear debug messages:', error); + } + }; + + const sendIPCMessage = async (messageType: string, data: any) => { + if (!isTauri) { + console.log(`[Browser Mode] Would send IPC message: ${messageType}`, data); + return; + } + + try { + await safeInvoke('send_ipc_message', { messageType, data }); + addDebugMessage('info', `IPC message sent: ${messageType}`, data); + } catch (error) { + console.error('Failed to send IPC message:', error); + addDebugMessage('error', `Failed to send IPC message: ${error}`); + } + }; + + const sendMessageToImages = async () => { + if (!messageToSend.trim()) return; + + const message = { + message: messageToSend, + timestamp: Date.now(), + source: 'gui' + }; + + try { + // Send via Tauri command to stdout (bypasses console hijacking) + await safeInvoke('send_message_to_stdout', { message: JSON.stringify(message) }); + + // Also add to our debug panel + addDebugMessage('info', `📤 Sent to images.ts: ${messageToSend}`, message); + } catch (error) { + console.error('Failed to send message to images.ts:', error); + addDebugMessage('error', `Failed to send message: ${error}`); + } + + // Clear the input + setMessageToSend(''); + }; + + + const saveGeneratedImage = async (generatedImage: GeneratedImage) => { + if (!isTauri) { + console.log('[Browser Mode] File save not available - downloading instead'); + // Browser fallback: trigger download + const base64Match = generatedImage.src.match(/^data:([^;]+);base64,(.+)$/); + if (base64Match) { + const link = document.createElement('a'); + link.download = `generated_${generatedImage.id}.png`; + link.href = generatedImage.src; + link.click(); + + // Mark as saved + setGeneratedImages(prev => + prev.map(img => + img.id === generatedImage.id + ? { ...img, saved: true } + : img + ) + ); + } + return; + } + + try { + if (!save || !writeFile) { + console.error('Save functions not available'); + return; + } + const defaultFilename = `generated_${generatedImage.id}.png`; const filePath = await save({ defaultPath: defaultFilename, @@ -314,12 +733,53 @@ function App() { } } catch (error) { console.error('Failed to save image:', error); - invoke('log_error_to_console', { error: `[Frontend Error] Failed to save image: ${JSON.stringify(error)}` }); + safeInvoke('log_error_to_console', { error: `[Frontend Error] Failed to save image: ${JSON.stringify(error)}` }); } }; async function openFilePicker() { + if (!isTauri) { + console.log('[Browser Mode] File picker not available'); + // Browser fallback: create file input + const input = document.createElement('input'); + input.type = 'file'; + input.multiple = true; + input.accept = 'image/*'; + input.onchange = (e) => { + const target = e.target as HTMLInputElement; + if (target.files) { + const fileArray = Array.from(target.files); + const newImageFiles: ImageFile[] = []; + let loadedCount = 0; + + fileArray.forEach(file => { + const reader = new FileReader(); + reader.onload = (e) => { + if (e.target?.result) { + newImageFiles.push({ + path: file.name, + src: e.target.result as string + }); + loadedCount++; + if (loadedCount === fileArray.length) { + setFiles(prevFiles => [...prevFiles, ...newImageFiles]); + } + } + }; + reader.readAsDataURL(file); + }); + } + }; + input.click(); + return; + } + try { + if (!open) { + console.error('Open function not available'); + return; + } + const selected = await open({ multiple: true, filters: [{ @@ -332,7 +792,7 @@ function App() { } } catch (e) { console.error('File picker error:', e); - invoke('log_error_to_console', { error: `[Frontend Error] File picker error: ${JSON.stringify(e)}` }); + safeInvoke('log_error_to_console', { error: `[Frontend Error] File picker error: ${JSON.stringify(e)}` }); } } @@ -354,104 +814,182 @@ function App() { } } catch (e) { console.error('Save dialog error:', e); - invoke('log_error_to_console', { error: `[Frontend Error] Save dialog error: ${JSON.stringify(e)}` }); + safeInvoke('log_error_to_console', { error: `[Frontend Error] Save dialog error: ${JSON.stringify(e)}` }); } } return ( -
-
-
-

Image Prompt

-
- Simple +
+ {/* Background decoration */} +
+
+
+
+ +
+
+

Image Prompt

+
+ {/* Debug Panel Toggle */} - Chat - {!apiKey && (API key required)} + + {/* Counter Display */} +
+ Counter: {counter} +
+ + +
+
+ + {/* Theme Toggle */} + + + {/* Chat Mode Toggle */} +
+ Simple + + Chat + {!apiKey && (API key required)} +
{ e.preventDefault(); submit(); }} > -