@j-o-r/hello-dave 0.1.1 → 0.1.5

package/lib/cdn.js

@@ -6,10 +6,8 @@
  *              Designed to be used by any toolset or agent (music, images, documents, etc.).
  *
  * Core capabilities:
- * - Publish single or multiple files into organized project folders
- * - Automatically create remote directory structures
- * - List all existing projects on the remote server
- * - Delete entire projects when no longer needed
+ * - Publish single or multiple files into public temp folders
+ * - Unpublish previously published files from public temp folders
  *
  * All public URLs are built dynamically from the SSH host (assumes a web server
  * is serving the `htdocs` directory publicly).
@@ -17,25 +15,6 @@
  * @requires SSH_EP environment variable (format: ssh://user@host:port)
  * @requires Remote host must have a web server serving the 'htdocs' folder
  *
- * @example
- * import cdn from './cdn.js';
- *
- * // Publish multiple files into one project
- * const result = await cdn.publishToProject(
- *   ['/tmp/audio.mp3', '/tmp/cover.jpg'],
- *   'my-song-cover-2026',
- *   {
- *     description: 'Cover of original song with new lyrics',
- *     plan: 'Two-step cover using Minimax voice features'
- *   }
- * );
- * console.log(result.public_urls);
- *
- * // List all projects
- * const projects = await cdn.listProjects();
- *
- * // Delete a project
- * await cdn.deleteProject('my-song-cover-2026');
  */
 
 import { SH } from '@j-o-r/sh';
@@ -53,7 +32,7 @@ import path from 'node:path';
  *
  * @example
  * // Required environment variable:
- * // export SSH_EP='ssh://jorrit@drive.duin.xyz:4301'
+ * // export SSH_EP='ssh://user@your-cdn.example.com:4301'
  */
 function getSshConfig() {
   if (!process.env.SSH_EP) {
@@ -92,6 +71,31 @@ function getSshConfig() {
   return { user, host, port, raw: ep };
 }
 
+/**
+ * Validate a CDN-relative path and normalize it for remote use.
+ *
+ * Paths are always relative to `htdocs/aaztmp/`. Absolute paths and parent
+ * directory traversal are rejected so delete operations cannot escape the CDN
+ * temp folder.
+ *
+ * @param {string} remoteRelativePath - Relative path under htdocs/aaztmp.
+ * @returns {string} Safe normalized POSIX-style relative path.
+ * @throws {Error} If the path is empty, absolute, or escapes the CDN temp root.
+ */
+function normalizeRemoteRelativePath(remoteRelativePath) {
+  if (typeof remoteRelativePath !== 'string' || !remoteRelativePath.trim()) {
+    throw new Error('remoteRelativePath must be a non-empty string');
+  }
+
+  const normalized = path.posix.normalize(remoteRelativePath.replaceAll('\\', '/'));
+
+  if (normalized === '.' || normalized.startsWith('../') || normalized === '..' || path.posix.isAbsolute(normalized)) {
+    throw new Error(`Invalid remoteRelativePath: "${remoteRelativePath}"`);
+  }
+
+  return normalized;
+}
+
 /**
  * Ensure a remote directory exists under `htdocs/`.
  * Creates all parent directories as needed (`mkdir -p`).
@@ -101,7 +105,7 @@ function getSshConfig() {
  */
 async function ensureRemoteDir(remoteRelativeDir) {
   const ssh = getSshConfig();
-  const remoteDir = `htdocs/${remoteRelativeDir}`;
+  const remoteDir = `htdocs/aaztmp/${remoteRelativeDir}`;
 
   console.log(`[cdn] Ensuring remote directory: ${remoteDir}`);
   await SH`ssh -p ${ssh.port} ${ssh.user}@${ssh.host} "mkdir -p ${remoteDir}"`.run();
@@ -125,198 +129,8 @@ function getOutput(result) {
 }
 
 /**
- * List all existing projects on the remote server.
- *
- * Scans the `htdocs/projects/` directory and returns metadata for each project.
- * Useful when starting without prior context about what has already been published.
- *
- * @returns {Promise<Array<{slug: string, url: string, fileCount: number, created?: string}>>}
- *          Array of project objects.
- *
- * @throws {Error} If the SSH connection or directory listing fails.
- *
- * @example
- * const projects = await cdn.listProjects();
- * console.log(projects[0].url); // https://drive.duin.xyz/projects/my-project/
- */
-async function listProjects() {
-  const ssh = getSshConfig();
-  const projectsBase = 'htdocs/projects';
-
-  console.log(`[cdn] Listing projects from ${ssh.host}...`);
-
-  try {
-    const lsResult = await SH`ssh -p ${ssh.port} ${ssh.user}@${ssh.host} "ls -1 ${projectsBase} 2>/dev/null || echo ''"`.run();
-    const output = getOutput(lsResult);
-    const slugs = output.trim().split('\n').filter(Boolean);
-
-    const projects = [];
-
-    for (const slug of slugs) {
-      const projectDir = `${projectsBase}/${slug}`;
-
-      const countResult = await SH`ssh -p ${ssh.port} ${ssh.user}@${ssh.host} "ls -1 ${projectDir} 2>/dev/null | wc -l"`.run();
-      const countOutput = getOutput(countResult);
-      const fileCount = parseInt(countOutput.trim(), 10) || 0;
-
-      let created;
-      try {
-        const metaResult = await SH`ssh -p ${ssh.port} ${ssh.user}@${ssh.host} "cat ${projectDir}/meta.json 2>/dev/null || echo '{}'"`.run();
-        const metaOutput = getOutput(metaResult);
-        const meta = JSON.parse(metaOutput.trim());
-        created = meta.created;
-      } catch (_) {
-        // meta.json may not exist yet
-      }
-
-      projects.push({
-        slug,
-        url: `https://${ssh.host}/projects/${slug}/`,
-        fileCount,
-        created
-      });
-    }
-
-    console.log(`[cdn] Found ${projects.length} project(s)`);
-    return projects;
-  } catch (err) {
-    throw new Error(`Failed to list projects: ${err.message}`);
-  }
-}
-
-/**
- * Delete an entire project folder from the remote server.
- *
- * Permanently removes `htdocs/projects/<slug>` and all its contents.
- * Use with caution — this operation cannot be undone.
- *
- * @param {string} projectSlug - Project identifier (will be sanitized to kebab-case)
- * @returns {Promise<{deleted: boolean, project: string}>}
- *
- * @example
- * await cdn.deleteProject('my-old-project');
- */
-async function deleteProject(projectSlug) {
-  const ssh = getSshConfig();
-  const slug = projectSlug.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
-  const remoteDir = `htdocs/projects/${slug}`;
-
-  console.log(`[cdn] Deleting project: ${remoteDir}`);
-  await SH`ssh -p ${ssh.port} ${ssh.user}@${ssh.host} "rm -rf ${remoteDir}"`.run();
-
-  console.log(`[cdn] ✅ Project deleted: ${slug}`);
-  return { deleted: true, project: slug };
-}
-
-/**
- * Ensure the remote project directory structure exists.
- * Creates `htdocs/projects/<slug>` (and the `generated` subfolder).
- *
- * @param {string} projectSlug - Project identifier (will be sanitized)
- * @returns {Promise<string>} The remote directory path under htdocs
- */
-async function ensureProjectStructure(projectSlug) {
-  const slug = projectSlug.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
-  const remoteRelative = `projects/${slug}`;
-  return await ensureRemoteDir(remoteRelative);
-}
-
-/**
- * Internal helper to upload a single file via SCP.
- *
- * @param {string} localPath - Local file path
- * @param {string} remoteFilePath - Full remote path (including htdocs)
- * @param {object} ssh - SSH config object from getSshConfig()
- */
-async function uploadSingleFile(localPath, remoteFilePath, ssh) {
-  const scpTarget = `${ssh.user}@${ssh.host}:${remoteFilePath}`;
-  console.log(`[cdn] Uploading: ${path.basename(localPath)} → ${remoteFilePath}`);
-  await SH`scp -P ${ssh.port} ${localPath} ${scpTarget}`.run();
-}
-
-/**
- * Publish one or more local files into an organized project folder on the public CDN.
- *
- * Supports both single file (string) and multiple files (array).
- * Automatically creates the project directory and generates `meta.json`.
- * Optional `description.md` and `plan.md` files can be created.
- *
- * @param {string|string[]} localPaths - Single path or array of local file paths
- * @param {string} projectSlug - Project identifier (sanitized to kebab-case)
- * @param {Object} [options]
- * @param {string} [options.description] - Human-readable project description
- * @param {string} [options.plan] - Planning notes or step-by-step evolution
- * @param {string} [options.filename] - Custom filename (only used when uploading a single file)
- *
- * @returns {Promise<{public_urls: string[], project_folder: string, meta: object}>}
- *
- * @example
- * // Multiple files
- * const result = await cdn.publishToProject(
- *   ['audio.mp3', 'cover.jpg'],
- *   'my-project',
- *   { description: 'Music cover project' }
- * );
- *
- * // Single file with custom name
- * await cdn.publishToProject('/tmp/file.mp3', 'my-project', { filename: 'final.mp3' });
- */
-async function publishToProject(localPaths, projectSlug, options = {}) {
-  const ssh = getSshConfig();
-  const slug = projectSlug.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
-  const remoteDir = await ensureProjectStructure(slug);
-
-  const paths = Array.isArray(localPaths) ? localPaths : [localPaths];
-  const uploadedFiles = [];
-
-  for (const localPath of paths) {
-    const filename = options.filename && paths.length === 1
-      ? options.filename
-      : path.basename(localPath);
-
-    const remoteFile = `${remoteDir}/${filename}`;
-    await uploadSingleFile(localPath, remoteFile, ssh);
-    uploadedFiles.push(filename);
-  }
-
-  const meta = {
-    project: slug,
-    created: new Date().toISOString(),
-    files: uploadedFiles,
-    source: 'cdn.js',
-    ssh_ep: ssh.raw
-  };
-
-  console.log(`[cdn] Writing meta.json`);
-  await SH`ssh -p ${ssh.port} ${ssh.user}@${ssh.host} "cat > ${remoteDir}/meta.json << 'EOF'
-${JSON.stringify(meta, null, 2)}
-EOF"`.run();
-
-  if (options.description) {
-    await SH`ssh -p ${ssh.port} ${ssh.user}@${ssh.host} "cat > ${remoteDir}/description.md << 'EOF'
-${options.description}
-EOF"`.run();
-  }
-
-  if (options.plan) {
-    await SH`ssh -p ${ssh.port} ${ssh.user}@${ssh.host} "cat > ${remoteDir}/plan.md << 'EOF'
-${options.plan}
-EOF"`.run();
-  }
-
-  const publicUrls = uploadedFiles.map(f => `https://${ssh.host}/projects/${slug}/${f}`);
-  const projectFolder = `https://${ssh.host}/projects/${slug}/`;
-
-  return {
-    public_urls: publicUrls,
-    project_folder: projectFolder,
-    meta
-  };
-}
-
-/**
- * Publish a single local file to an arbitrary location on the public CDN.
- *
+ * Publish a single local file to an arbitrary temp location on the public CDN.
+ * this folder is cleared regulary.
  * Automatically creates any missing parent directories.
  * Returns a direct public HTTPS URL.
  *
@@ -334,40 +148,62 @@ EOF"`.run();
  */
 async function publishFile(localPath, remoteRelativePath) {
   const ssh = getSshConfig();
-  const remoteDir = path.dirname(remoteRelativePath);
+  const safeRemoteRelativePath = normalizeRemoteRelativePath(remoteRelativePath);
+  const remoteDir = path.dirname(safeRemoteRelativePath);
 
   if (remoteDir && remoteDir !== '.') {
     await ensureRemoteDir(remoteDir);
   }
 
-  const remoteTarget = `${ssh.user}@${ssh.host}:htdocs/${remoteRelativePath}`;
+  const remoteTarget = `${ssh.user}@${ssh.host}:htdocs/aaztmp/${safeRemoteRelativePath}`;
 
   console.log(`[cdn] Uploading via SCP: ${localPath} → ${remoteTarget}`);
   await SH`scp -P ${ssh.port} ${localPath} ${remoteTarget}`.run();
   console.log(`[cdn] ✅ Upload successful`);
 
   return {
-    public_url: `https://${ssh.host}/${remoteRelativePath}`,
+    public_url: `https://${ssh.host}/aaztmp/${safeRemoteRelativePath}`,
     remote_path: remoteTarget
   };
 }
 
+/**
+ * Delete a previously published file from the public CDN temp folder.
+ *
+ * The target path is resolved relative to `htdocs/aaztmp/`. Missing files are
+ * treated as already unpublished because `rm -f` is used.
+ *
+ * @param {string} remoteRelativePath - File path under htdocs/aaztmp (e.g. "tmp/quick-reference.mp3")
+ * @returns {Promise<{public_url: string, remote_path: string, unpublished: boolean}>}
+ *
+ * @example
+ * const result = await cdn.unpublishFile('tmp/quick-reference.mp3');
+ * console.log(result.unpublished);
+ */
+async function unpublishFile(remoteRelativePath) {
+  const ssh = getSshConfig();
+  const safeRemoteRelativePath = normalizeRemoteRelativePath(remoteRelativePath);
+  const remoteFile = `htdocs/aaztmp/${safeRemoteRelativePath}`;
+
+  console.log(`[cdn] Deleting remote file: ${remoteFile}`);
+  await SH`ssh -p ${ssh.port} ${ssh.user}@${ssh.host} rm -f ${remoteFile}`.run();
+  console.log('[cdn] ✅ Delete successful');
+
+  return {
+    public_url: `https://${ssh.host}/aaztmp/${safeRemoteRelativePath}`,
+    remote_path: `${ssh.user}@${ssh.host}:${remoteFile}`,
+    unpublished: true
+  };
+}
+
 export {
   getSshConfig,
-  ensureRemoteDir,
-  ensureProjectStructure,
-  listProjects,
-  deleteProject,
   publishFile,
-  publishToProject
+  unpublishFile,
 };
 
 export default {
   getSshConfig,
-  ensureRemoteDir,
-  ensureProjectStructure,
-  listProjects,
-  deleteProject,
   publishFile,
-  publishToProject
-};
+  unpublishFile,
+};

package/lib/{CdnToolset.js → cdnToolset.js}

@@ -21,6 +21,17 @@ import cdn from './cdn.js';
 
 const tools = new ToolSet('auto');
 
+/**
+ * Stringify a structured tool response with stable formatting.
+ * Structured CDN responses preserve exact public URLs and remote paths so the
+ * assistant can repeat them in normal conversation before raw tool-call history
+ * is pruned.
+ *
+ * @param {Record<string, *>} payload - JSON-serializable tool response payload.
+ * @returns {string} Formatted JSON function response.
+ */
+const json = (payload) => JSON.stringify(payload, null, 2);
+
 /**
  * Single source of truth for cleaning over-escaped strings from LLMs.
  * (Duplicated here for self-containment of the CDN toolset)
@@ -89,32 +100,21 @@ const guessOverEscaping = (s) => {
  *   to a remote web server defined by the SSH_EP environment variable).
  *
  * Logical workflow for LLMs:
- *   1. listProjects()      → Discover what already exists
- *   2. publishFile()       → Quick single-file exposure
- *   3. publishToProject()  → Organize one or multiple files into a project
- *   4. deleteProject()     → Clean up when no longer needed
+ *   1. publishFile()       → Quick single-file exposure
+ *   2. unpublishFile()     → Delete a previously published file
  *
  * Requirements:
  *   - SSH_EP environment variable must be set
  *   - Remote host serves the 'htdocs' folder publicly over HTTPS
  */
 
-tools.add(
-	'list_projects',
-	'List all existing projects published on the remote public server.\n' +
-	'Returns slug, public URL, file count, and creation date for each project.\n' +
-	'Use this first when you have no prior context about what has already been published.',
-	{ type: 'object', properties: {} },
-	async () => {
-		return await cdn.listProjects();
-	}
-);
 
 tools.add(
 	'publish_file',
-	'Publish a single local file to a public HTTPS URL via SSH.\n' +
+	'Publish a single local file to a public temp folder HTTPS URL via SSH.\n' +
 	'Automatically creates any missing parent directories.\n' +
-	'Best for quick one-off references or when you only need a direct link to one file.',
+	'Best for quick one-off references or when you only need a direct link to one file.\n' +
+	'Returns structured JSON with public_url and remote_path. After success, include the exact public_url in your assistant response so it remains available after old tool calls are pruned.',
 	{
 		type: 'object',
 		properties: {
@@ -126,66 +126,49 @@ tools.add(
 	async (params) => {
 		let local = guessOverEscaping(params.localPath).trim();
 		let remote = guessOverEscaping(params.remoteRelativePath).trim();
-		return await cdn.publishFile(local, remote);
+		const result = await cdn.publishFile(local, remote);
+		return json({
+			tool: 'publish_file',
+			success: true,
+			localPath: local,
+			remoteRelativePath: remote,
+			public_url: result.public_url,
+			publicUrl: result.public_url,
+			remote_path: result.remote_path,
+			note: 'Assistant: tell the user the exact public_url. Use public_url as the durable reference for later image_url/audio_url/file URL inputs.'
+		});
 	}
 );
 
-tools.add(
-	'publish_to_project',
-	'Publish one or multiple local files into a structured public project folder.\n' +
-	'Creates the project directory, uploads all files, and generates meta.json.\n' +
-	'Optional description.md and plan.md can be added for context.\n' +
-	'Returns an array of public URLs plus the project folder URL.\n' +
-	'Recommended when you want to keep related files together for remote AI inspection.',
-	{
-		type: 'object',
-		properties: {
-			localPaths: {
-				oneOf: [
-					{ type: 'string', description: 'Single file path' },
-					{ type: 'array', items: { type: 'string' }, description: 'Array of file paths' }
-				]
-			},
-			projectSlug: { type: 'string', description: 'Project folder name (will be sanitized to kebab-case)' },
-			options: {
-				type: 'object',
-				properties: {
-					description: { type: 'string', description: 'Human-readable description of the project' },
-					plan: { type: 'string', description: 'Planning notes or step-by-step evolution' },
-					filename: { type: 'string', description: 'Custom filename (only used for single-file uploads)' }
-				}
-			}
-		},
-		required: ['localPaths', 'projectSlug']
-	},
-	async (params) => {
-		let localPaths = guessOverEscaping(params.localPaths);
-		if (typeof localPaths === 'string') localPaths = [localPaths];
-
-		let projectSlug = guessOverEscaping(params.projectSlug).trim();
-		let options = params.options || {};
-		if (typeof options === 'string') options = JSON.parse(guessOverEscaping(options));
-
-		return await cdn.publishToProject(localPaths, projectSlug, options);
-	}
-);
 
 tools.add(
-	'delete_project',
-	'Permanently delete an entire project folder from the remote public server.\n' +
-	'Removes the project and all its files.\n' +
-	'Use this to clean up temporary or obsolete projects.',
+	'unpublish_file',
+	'Delete a previously published file from the public temp folder via SSH.\n' +
+	'The path is relative to htdocs/aaztmp and must match the remoteRelativePath used for publish_file.\n' +
+	'Missing files are treated as already unpublished.\n' +
+	'Returns structured JSON with public_url, remote_path, and unpublished status. After success, tell the user the exact public_url that was removed.',
 	{
 		type: 'object',
 		properties: {
-			projectSlug: { type: 'string', description: 'Project slug to delete' }
+			remoteRelativePath: { type: 'string', description: 'File path under htdocs/aaztmp to delete (e.g. "tmp/reference.mp3" or "projects/my-project/audio.wav")' }
 		},
-		required: ['projectSlug']
+		required: ['remoteRelativePath']
 	},
 	async (params) => {
-		let slug = guessOverEscaping(params.projectSlug).trim();
-		return await cdn.deleteProject(slug);
+		let remote = guessOverEscaping(params.remoteRelativePath).trim();
+		const result = await cdn.unpublishFile(remote);
+		return json({
+			tool: 'unpublish_file',
+			success: true,
+			remoteRelativePath: remote,
+			public_url: result.public_url,
+			publicUrl: result.public_url,
+			remote_path: result.remote_path,
+			unpublished: result.unpublished,
+			note: 'Assistant: tell the user the exact public_url that was removed and do not use it as a durable reference anymore.'
+		});
 	}
 );
 
+
 export default tools;

package/lib/defaultToolsets.js

@@ -0,0 +1,43 @@
+import minimax from './API/minimax/index.js';
+import mureka from './API/mureka/index.js';
+import stability from './API/stability.ai/index.js';
+import xaitools from './API/x.ai/index.js';
+import openaitools from './API/openai.com/index.js';
+import genTools from './genericToolset.js';
+import cdnTools from './cdnToolset.js';
+import handoffTools, { createHandOffToolset } from './handOffToolset.js';
+
+/**
+ * Default framework-owned toolset tree exposed as API.toolset.
+ *
+ * @type {Record<string, Record<string, any>>}
+ */
+const defaultToolsets = {
+  minimax: {
+    music: minimax.musicToolset,
+    image: minimax.imageToolset,
+    video: minimax.videoToolset
+  },
+  stability: {
+    image: stability.imageToolset,
+    music: stability.musicToolset
+  },
+  mureka: {
+    music: mureka.musicToolset
+  },
+  xai: {
+    image: xaitools.imageToolset
+  },
+  openai: {
+    video: openaitools.videoToolset
+  },
+  generic: {
+    bash: genTools,
+    cdn: cdnTools,
+    handoff: handoffTools,
+    createHandoff: createHandOffToolset
+  }
+};
+
+export { createHandOffToolset };
+export default defaultToolsets;

package/lib/fafs.js

@@ -79,7 +79,7 @@ async function systemInfo() {
 
 /**
  * Gathers comprehensive environment information: user name, fresh system details, IP-based geolocation,
- * and normalized current working directory. Results are cached in ~/.cache/hello-dave/env for 31 days,
+ * and normalized current working directory. Results are cached in ~/.cache/@j-o-r/hello-dave/env for 31 days,
  * refreshed on expiry. On cache hit, updates with fresh system info and cwd.
  * 
  * @returns {Promise<EnvironmentInfo>} The environment information object.