@j-o-r/hello-dave 0.0.10 → 0.1.0

package/lib/genericToolset.js

@@ -13,6 +13,9 @@ const searchSessionsSh = path.join(utilsDir, 'search_sessions.sh');
 const listSessionsSh = path.join(utilsDir, 'list_sessions.sh');
 const syntaxCheckSh = path.join(utilsDir, 'syntax_check.sh');
 
+// Do we have a SSH access point?
+const SSH_EP = process.env.SSH_EP || '';
+
 const user = await env();
 const environment = `
 Name: ${user.name}
@@ -27,8 +30,6 @@ const tools = new ToolSet('auto');
 
 /**
  * Single source of truth for cleaning over-escaped strings from LLMs.
- * Basic cleaning only. Heavy repair (especially for JS template literals)
- * is now centralized in utils/syntax_check.sh (repair_file logic).
  */
 const guessOverEscaping = (s) => {
 	if (typeof s !== 'string') return s;
@@ -94,10 +95,6 @@ const getJSError = (errorStr) => {
 /**
  * @module lib/genericToolset
  * Secure utility tools. 
- * write_file writes content, then runs syntax_check.sh WITHOUT --fix.
- * On syntax error the error details are returned in the tool response
- * (file is kept so LLM agents can read_file, inspect escaping issues,
- * and submit a corrected version on the next write_file call).
  */
 
 tools.add(
@@ -144,71 +141,39 @@ tools.add(
 		properties: {
 			bash_script: {
 				type: 'string',
-				description: `
-**Write raw bash exactly** as it should appear in a .sh file. Use normal bash escaping only (\`'\\''\` for single quotes inside single quotes, \`\\$\` for literal dollar, etc.).
-
-Do NOT add extra backslashes for JSON, JavaScript, or XML. The system parses the JSON then passes your exact text to bash via stdin.
-
-Correct example you should output in the parameter:
-
-\`\`\`bash
-echo 'Single quotes: '\\''quoted'\\'''
-echo "Double quotes: \\"quoted\\""
-echo "Dollar: \\$HOME = $HOME"
-echo \\\`date\\\`
-echo -e 'Pipe test:\\n1\\n2' | cat
-\`\`\`
-Supports all syntax safely via stdin. System: ${user.system}`
+				description: `Write raw bash exactly...`
 			},
-			timeout: {
-				type: 'number',
-				default: 360,
-				description: 'Max execution time in seconds (default 360).'
-			},
-			strict: {
-				type:'boolean' ,
-				default: false,
-				description: 'Validate bash script STRICT first before it is being executed.'
-			}
+			timeout: { type: 'number', default: 360 },
+			strict: { type: 'boolean', default: false }
 		},
 		required: ['bash_script']
 	},
 	async (params) => {
-		function escapeForBashTemplate(bashContent) {
-			return bashContent;
+		let bash_script = params.bash_script;
+		if (typeof bash_script !== 'string') bash_script = '';
+		// Check if the bash_script string has a shebang on the first line '#!'
+		// If not, add a bash shebang
+		const firstLine = bash_script.split('\n')[0] || '';
+		if (!firstLine.trim().startsWith('#!')) {
+			bash_script = '#!/bin/bash\n' + bash_script;
 		}
-		const timeoutSec = Number(params.timeout ?? 300);
-		const prams = params.strict? '' : '-S error';
-		const bash_script = escapeForBashTemplate(params.bash_script);
+		const timeoutSec = Number(params.timeout ?? 360);
+		const prams = params.strict ? '' : '-S error';
 		if (isNaN(timeoutSec) || timeoutSec < 0) throw new Error('Invalid timeout');
-		console.log(bash_script);
 		const timeout = timeoutSec * 1000;
 		const valid = SH`shellcheck ${prams} -`.runSync(bash_script).stdout.toString().trim();
-		if (valid !== '') {
-			console.log(valid);
-			throw new Error(valid);
-		}
+		if (valid !== '') throw new Error(valid);
 		return await SH`bash`.options({ timeout }).run(bash_script);
 	}
 );
 
 tools.add(
-	'send_email',
-	'Send email via msmtp.',
-	{
-		type: 'object',
-		properties: {
-			to: { type: 'string', description: 'Recipient' },
-			subject: { type: 'string', description: 'Subject' },
-			body: { type: 'string', description: 'Body' }
-		},
-		required: ['to', 'subject', 'body']
-	},
+	'send_email', 'Send email via msmtp.', { type: 'object', properties: { to: { type: 'string' }, subject: { type: 'string' }, body: { type: 'string' } }, required: ['to', 'subject', 'body'] },
 	async (params) => {
 		const to = guessOverEscaping(params.to);
 		const subject = guessOverEscaping(params.subject);
 		const body = guessOverEscaping(params.body);
-		const delim = `END_EMAIL_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+		const delim = `END_EMAIL_${Date.now().toString(36)}`;
 		return await SH`msmtp ${params.to} <<'${delim}'
 To: ${to}
 Subject: ${subject}
@@ -220,168 +185,80 @@ ${delim}
 );
 
 tools.add(
-	'open_link',
-	'Open URL/file with xdg-open.',
-	{
-		type: 'object',
-		properties: {
-			url: { type: 'string', description: 'URL or file path' }
-		},
-		required: ['url']
-	},
-	async (params) => {
-		let url = guessOverEscaping(params.url?.trim());
-		return await SH`xdg-open ${[url]}`.run();
-	}
+	'open_link', 'Open URL/file with xdg-open.', { type: 'object', properties: { url: { type: 'string' } }, required: ['url'] },
+	async (params) => await SH`xdg-open ${[guessOverEscaping(params.url)]}`.run()
 );
 
 tools.add(
-	'execute_remote_script',
-	'Run bash on remote via SSH.',
+	'execute_remote_script', `Run bash on remote via SSH. ${SSH_EP}`,
 	{
 		type: 'object',
 		properties: {
-			url: { type: 'string', description: 'ssh://user@host[:port]' },
-			script: { type: 'string', description: 'Raw script' },
-			timeout: {
-				type: 'number',
-				default: 30,
-				description: 'Max execution time in seconds (default 30).'
-			}
+			url: { type: 'string', description: `ssh://user@host[:port] default: ${SSH_EP}` },
+			script: { type: 'string' },
+			timeout: { type: 'number', default: 30 }
 		},
 		required: ['url', 'script']
 	},
 	async (params) => {
 		let { url, script } = params;
+		if (!url || url === '') url = SSH_EP;
 		url = guessOverEscaping(url);
 		script = guessOverEscaping(script);
-
-		const timeoutSec = Number(params.timeout ?? 30);
-		if (isNaN(timeoutSec) || timeoutSec <= 0) throw new Error('Invalid timeout');
-		const timeoutMs = timeoutSec * 1000;
+		const timeoutMs = (Number(params.timeout ?? 30)) * 1000;
 		if (!url.startsWith('ssh://')) throw new Error('ssh://user@host[:port]');
 		const withoutProto = url.slice(6);
 		const parts = withoutProto.split(':');
 		let port = 22, userHost = withoutProto;
 		if (parts.length > 1) { userHost = parts[0]; port = parseInt(parts[1]); }
 		const [user, host] = userHost.split('@');
-		if (!user || !host) throw new Error('Invalid SSH URL');
 		return await SH`ssh -p ${port} ${user}@${host} bash`.options({ timeout: timeoutMs }).run(script);
 	}
 );
 
 tools.add(
-	'history_search',
-	'Search/list chat sessions in .cache/.',
-	{
-		type: 'object',
-		properties: {
-			query: { type: 'string', description: 'Query/regex or empty to list' }
-		},
-		required: []
-	},
+	'history_search', 'Search/list chat sessions in .cache/.',
+	{ type: 'object', properties: { query: { type: 'string' } } },
 	async (params) => {
 		if (typeof params.query === 'string' && params.query.trim()) {
-			const q = guessOverEscaping(params.query);
-			return await SH`${searchSessionsSh} "${bashEscape(q)}"`.run();
+			return await SH`${searchSessionsSh} "${bashEscape(guessOverEscaping(params.query))}"`.run();
 		}
 		return await SH`${listSessionsSh}`.run();
 	}
 );
 
 tools.add(
-	'read_file',
-	'Read file from CWD (relative path only).',
-	{
-		type: 'object',
-		properties: {
-			file: { type: 'string', description: `Relative path. cwd: ${user.cwd}` }
-		},
-		required: ['file']
-	},
+	'read_file', 'Read file from CWD (relative path only).',
+	{ type: 'object', properties: { file: { type: 'string' } }, required: ['file'] },
 	async (params) => {
 		let file = guessOverEscaping(params.file?.trim());
-		if (typeof file !== 'string' || !file || file.startsWith('/') || file.includes('..') || file.includes('\\')) {
-			throw new Error('Relative CWD path only (no /, .., \\).');
-		}
-		const resolved = path.resolve(process.cwd(), file);
-		if (!resolved.startsWith(process.cwd())) throw new Error('Escapes CWD.');
-		return await fs.readFile(resolved, 'utf8');
+		if (!file || file.startsWith('/') || file.includes('..')) throw new Error('Relative CWD path only');
+		return await fs.readFile(path.resolve(process.cwd(), file), 'utf8');
 	}
 );
 
 tools.add(
-	'write_file',
-	'Write/validate file in CWD. Writes content to file then runs syntax_check.sh (no --fix). Syntax errors (if any) are reported back in the response so LLM can inspect escaping and correct on next call. File is kept on error.',
-	{
-		type: 'object',
-		properties: {
-			file: { type: 'string', description: `Relative path. cwd: ${user.cwd}` },
-			content: { type: 'string', description: 'Raw content verbatim (no escaping).' }
-		},
-		required: ['file', 'content']
-	},
+	'write_file', 'Write/validate file in CWD.',
+	{ type: 'object', properties: { file: { type: 'string' }, content: { type: 'string' } }, required: ['file', 'content'] },
 	async (params) => {
 		let fileParam = guessOverEscaping(params.file?.trim());
-		let content = guessOverEscaping(params.content ? params.content : '');
-
-		if (typeof fileParam !== 'string' || !fileParam || fileParam.startsWith('/') || fileParam.includes('..') || fileParam.includes('\\')) {
-			throw new Error('Relative CWD path only (no /, .., \\).');
-		}
+		let content = guessOverEscaping(params.content || '');
+		if (!fileParam || fileParam.startsWith('/') || fileParam.includes('..')) throw new Error('Relative CWD path only');
 		const resolved = path.resolve(process.cwd(), fileParam);
-		if (!resolved.startsWith(process.cwd())) throw new Error('Escapes CWD.');
-
-		const dir = path.dirname(resolved);
-		await fs.mkdir(dir, { recursive: true });
+		await fs.mkdir(path.dirname(resolved), { recursive: true });
 		await fs.writeFile(resolved, content, 'utf8');
-
-		let validationMsg = '';
-		try {
-			const checkOutput = await SH`${syntaxCheckSh} ${resolved}`.run();
-			validationMsg = checkOutput ? ` ${checkOutput.trim()}` : ' ✓ Syntax OK';
-		} catch (checkErr) {
-			const errText = checkErr?.toString() || 'Unknown syntax error';
-			validationMsg = ` [Syntax Error] ${getJSError(errText) || errText}`;
-			// File is intentionally kept so LLM can read_file and fix escaping
-		}
-
-		if (content.trim().startsWith('#!')) {
-			try {
-				await SH`chmod +x ${[resolved]}`.run();
-				validationMsg += ' ✓ +x';
-			} catch (e) {
-				validationMsg += ' (chmod failed)';
-			}
-		}
-
-		return `Wrote ${fileParam} (${Buffer.byteLength(content, 'utf8')} bytes).${validationMsg}`;
+		return `Wrote ${fileParam} (${Buffer.byteLength(content, 'utf8')} bytes).`;
 	}
 );
 
 tools.add(
-	'syntax_check',
-	'Syntax validate file via utils/syntax_check.sh.',
-	{
-		type: 'object',
-		properties: {
-			file: { type: 'string', description: 'Relative CWD path' }
-		},
-		required: ['file']
-	},
+	'syntax_check', 'Syntax validate file via utils/syntax_check.sh.',
+	{ type: 'object', properties: { file: { type: 'string' } }, required: ['file'] },
 	async (params) => {
 		const file = guessOverEscaping(params.file?.trim());
-		if (typeof file !== 'string' || !file) throw new Error('Relative path required.');
 		const resolved = path.resolve(process.cwd(), file);
-		if (!resolved.startsWith(process.cwd())) throw new Error('Escapes CWD.');
-
-		const args = resolved;
-		try {
-			const out = await SH`${syntaxCheckSh} ${args}`.run();
-			return out || 'Syntax validation passed';
-		} catch (e) {
-			return `Syntax check failed: ${e.toString()}`;
-		}
+		return await SH`${syntaxCheckSh} ${resolved}`.run() || 'Syntax OK';
 	}
 );
 
-export default tools;
+export default tools;

package/lib/index.js

@@ -2,7 +2,9 @@ import {request as gpt} from './API/openai.com/reponses/text.js';
 import {request as xai} from './API/x.ai/responses.js';
 import {request as claude} from './API/anthropic.com/text.js';
 import {request as brave} from './API/brave.com/search.js';
-
+import minimax from './API/minimax/index.js';
+import stability from './API/stability.ai/index.js';
+import xai from './API/x.ai/index.js';
 import { env, GLOBAL } from './fafs.js';
 import ToolSet from './ToolSet.js';
 import AgentServer from './AgentServer.js';
@@ -23,6 +25,9 @@ const API = {
   search: {
   	brave
   },
+  minimax,
+  stability,
+  xai
 }
 export {
 	AgentManager,
@@ -38,3 +43,6 @@ export {
   wsCli,
   wsIO
 };
+
+// Export the dedicated CDN toolset
+export { default as CdnToolset } from './CdnToolset.js';

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@j-o-r/hello-dave",
   "type": "module",
-  "version": "0.0.10",
-  "description": "ESM toolkit for building AI agents with unified access to Grok (XAI), OpenAI, and Anthropic endpoints",
+  "version": "0.1.0",
+  "description": "ESM toolkit for building AI agents, CLI xai coding agent and unified access to Grok (XAI), OpenAI, and Anthropic endpoints, music, image and video creation toolsets from minimax, stability and x.ai.",
   "main": "./lib/index.js",
   "types": "./types/index.d.ts",
   "typesVersions": {

package/types/API/minimax/ImageToolset.d.ts

@@ -0,0 +1,3 @@
+export default tools;
+declare const tools: ToolSet;
+import ToolSet from '../../ToolSet.js';

package/types/API/minimax/MusicToolset.d.ts

@@ -0,0 +1,3 @@
+export default tools;
+declare const tools: ToolSet;
+import ToolSet from '../../ToolSet.js';

package/types/API/minimax/VideoToolset.d.ts

@@ -0,0 +1,3 @@
+export default tools;
+declare const tools: ToolSet;
+import ToolSet from '../../ToolSet.js';

package/types/API/minimax/image.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Get authentication headers for Minimax API.
+ *
+ * @returns {Object} Headers object with Authorization Bearer token.
+ * @throws {Error} If MINIMAX_API_KEY environment variable is not set.
+ */
+export function getHeaders(): Object;
+/**
+ * Saves image data (either URL or base64) to a local temporary file.
+ * Handles both `response_format: 'url'` and `response_format: 'base64'`.
+ * Supports data URL prefix for base64.
+ *
+ * @param {string} imageData - Either a URL or a base64-encoded string (with or without data: prefix).
+ * @param {string} [filenamePrefix='minimax-image'] - Prefix for the local filename.
+ * @param {number} [index=0] - Index for multiple images to avoid filename collisions.
+ * @returns {Promise<string>} Absolute path to the saved local file.
+ */
+export function saveImageToLocal(imageData: string, filenamePrefix?: string, index?: number): Promise<string>;
+/**
+ * Core image generation request (supports both Text-to-Image and Image-to-Image).
+ *
+ * Fully implements the official Minimax Image Generation API
+ * as documented in `lib/API/minimax/image.generation.md` and `image.to.image.md`.
+ *
+ * Uses the single endpoint `/v1/image_generation`.
+ *
+ * Supports all models, parameters, and response formats.
+ *
+ * @param {string} prompt - Text description of the image, max 1500 characters.
+ * @param {Object} [options] - All available options from the official spec.
+ *
+ * @param {string} [options.model='image-01'] - Model to use.
+ *   Supported values:
+ *   - 'image-01' (default, text-to-image and img2img)
+ *   - 'image-01-live' (for image-to-image)
+ *
+ * @param {string} [options.aspect_ratio='1:1'] - Image aspect ratio.
+ *   Options: '1:1', '16:9', '4:3', '3:2', '2:3', '3:4', '9:16', '21:9'
+ *
+ * @param {number} [options.width] - Image width in px (512-2048, divisible by 8).
+ *   Only effective for model 'image-01'. aspect_ratio takes priority if both provided.
+ *
+ * @param {number} [options.height] - Image height in px (same rules as width).
+ *
+ * @param {string} [options.response_format='url'] - 'url' or 'base64'.
+ *   Default is `'url'` (user preference).
+ *   ⚠️ `url` links expire after 24 hours.
+ *
+ * @param {number} [options.seed] - Random seed for reproducibility.
+ *
+ * @param {number} [options.n=1] - Number of images to generate (1-9).
+ *
+ * @param {boolean} [options.prompt_optimizer=false] - Enable automatic prompt optimization.
+ *
+ * @param {Array<Object>} [options.subject_reference] - For Image-to-Image.
+ *   Array of subject references. Currently supports:
+ *   - { type: 'character', image_file: 'https://...' or 'data:image/...;base64,...' }
+ *
+ * @param {Object} [options.extra] - Any additional parameters not yet documented.
+ *
+ * @returns {Promise<{
+ *   image_urls: string[],        // Array from data.image_urls (if url format)
+ *   image_base64: string[],      // Array from data.image_base64 (if base64 format)
+ *   local_paths: string[],       // Absolute paths to saved files
+ *   metadata: Object,            // { success_count, failed_count }
+ *   id: string,                  // Trace ID
+ *   duration: number,            // API call duration in milliseconds
+ *   raw: object                  // Full raw response
+ * }>}
+ *
+ * @example
+ * // Text-to-Image (basic)
+ * const result = await requestImage("A serene mountain landscape at sunset", {
+ *   model: "image-01",
+ *   aspect_ratio: "16:9",
+ *   n: 2
+ * });
+ *
+ * @example
+ * // Image-to-Image
+ * const result = await requestImage("A girl looking into the distance", {
+ *   model: "image-01",
+ *   subject_reference: [{
+ *     type: "character",
+ *     image_file: "https://example.com/portrait.jpg"
+ *   }],
+ *   n: 1
+ * });
+ */
+export function requestImage(prompt: string, options?: {
+    model?: string | undefined;
+    aspect_ratio?: string | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+    response_format?: string | undefined;
+    seed?: number | undefined;
+    n?: number | undefined;
+    prompt_optimizer?: boolean | undefined;
+    subject_reference?: Object[] | undefined;
+    extra?: Object | undefined;
+}): Promise<{
+    image_urls: string[];
+    image_base64: string[];
+    local_paths: string[];
+    metadata: Object;
+    id: string;
+    duration: number;
+    raw: object;
+}>;

package/types/API/minimax/index.d.ts

@@ -0,0 +1,15 @@
+declare namespace _default {
+    export { music };
+    export { musicToolset };
+    export { video };
+    export { videoToolset };
+    export { image };
+    export { imageToolset };
+}
+export default _default;
+import * as music from './music.js';
+import musicToolset from './MusicToolset.js';
+import * as video from './video.js';
+import videoToolset from './VideoToolset.js';
+import * as image from './image.js';
+import imageToolset from './ImageToolset.js';

package/types/API/minimax/music.d.ts

@@ -0,0 +1,46 @@
+export function getHeaders(): {
+    'Content-Type': string;
+    Authorization: string;
+};
+export function saveAudioToLocal(audioData: any, filenamePrefix?: string): Promise<any>;
+export function createMusic(prompt: any, options?: {}): Promise<{
+    audio_url: any;
+    local_path: any;
+    duration: number;
+    raw: any;
+}>;
+export function changeMusic(prompt: any, options?: {}): Promise<{
+    audio_url: any;
+    local_path: any;
+    duration: number;
+    raw: any;
+}>;
+export function analyzeMusic(audioUrl: any, options?: {}): Promise<{
+    cover_feature_id: any;
+    formatted_lyrics: any;
+    structure_result: any;
+    audio_duration: any;
+    trace_id: any;
+    raw: any;
+}>;
+/**
+ * Generate complete song lyrics or edit/continue existing lyrics.
+ *
+ * @param {string} prompt - Theme, style, or editing instruction.
+ * @param {Object} [options]
+ * @param {'write_full_song'|'edit'} [options.mode='write_full_song']
+ * @param {string} [options.lyrics] - Existing lyrics (required for edit mode)
+ * @param {string} [options.title]
+ *
+ * @returns {Promise<{song_title: string, style_tags: string, lyrics: string, raw: object}>}
+ */
+export function generateLyrics(prompt: string, options?: {
+    mode?: "write_full_song" | "edit" | undefined;
+    lyrics?: string | undefined;
+    title?: string | undefined;
+}): Promise<{
+    song_title: string;
+    style_tags: string;
+    lyrics: string;
+    raw: object;
+}>;