promptmic 0.1.2 → 0.1.3

package/README.md

@@ -71,6 +71,12 @@ If you want the browser to open automatically:
 npx promptmic --open
 ```
 
+If you want to delete the saved local config and start fresh:
+
+```bash
+npx promptmic --reset-config
+```
+
 If you install it globally, the executable name is:
 
 ```bash
@@ -171,6 +177,18 @@ If you want to use shell wrappers or functions such as `personal` or `work`, the
 - `npm run start:repo`: forces `./config.json`
 - `npx promptmic`: should behave like `npm run start`
 
+To reset the default local config file used by the published CLI:
+
+```bash
+npx promptmic --reset-config
+```
+
+To reset a specific config file instead:
+
+```bash
+npx promptmic --config ./config.json --reset-config
+```
+
 ### Provider fields
 
 | Field | Type | Required | Description |
@@ -184,9 +202,19 @@ If you want to use shell wrappers or functions such as `personal` or `work`, the
 ### Execution modes
 
 - `direct` is the recommended default for most providers because it runs the CLI directly and avoids shell startup noise
+- on macOS and Linux, `direct` also probes the user's interactive shell to recover user PATH entries when the app was launched from a GUI or another stripped-down environment
 - `shell` is useful when you rely on shell wrappers, aliases, or functions such as `personal`, `work`, or custom environment bootstrap commands
+- `direct` still requires a real executable; aliases and shell functions remain a `shell` use case
 - In `shell` mode, anything printed by your shell startup files can appear at the start of the session
 
+### Troubleshooting command resolution
+
+- If a provider works in your terminal but fails inside TermSpeak, prefer `direct` with a real executable name or absolute path
+- If the executable lives in a user-managed bin directory such as `~/.local/bin`, `~/.nvm/.../bin`, or a Homebrew prefix, TermSpeak will try to recover those PATH entries from your interactive shell on macOS and Linux
+- For maximum portability across macOS, Linux, and Windows, use an absolute executable path when you can
+- If you depend on aliases, shell functions, or wrapper commands, switch that provider to `shell`
+- You can also set `PATH` explicitly in the provider `env` when you need a fully controlled runtime environment
+
 ### Example: multiple Claude accounts with direct execution
 
 ```json

package/apps/server/dist/pty-spawner.js

@@ -1,7 +1,22 @@
 import pty from 'node-pty';
+import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { HOME_DIR } from './runtime-config.js';
+function getEnvValue(env, key, platform) {
+    if (platform !== 'win32')
+        return env[key];
+    const actualKey = Object.keys(env).find((candidate) => candidate.toLowerCase() === key.toLowerCase());
+    return actualKey ? env[actualKey] : undefined;
+}
+function setEnvValue(env, key, value, platform) {
+    if (platform !== 'win32') {
+        env[key] = value;
+        return;
+    }
+    const actualKey = Object.keys(env).find((candidate) => candidate.toLowerCase() === key.toLowerCase()) ?? key;
+    env[actualKey] = value;
+}
 function isExecutable(filePath, platform) {
     try {
         fs.accessSync(filePath, platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK);
@@ -60,8 +75,15 @@ function readShebang(filePath) {
         return null;
     }
 }
-function resolveDirectSpawnTarget(command, args, env, platform) {
-    const executable = resolveDirectExecutable(command, env.PATH, platform, env.PATHEXT) ?? command;
+function resolveDirectSpawnTarget(command, args, env, platform, userShell, execFileSyncFn) {
+    const executableFromPath = resolveDirectExecutable(command, getEnvValue(env, 'PATH', platform), platform, getEnvValue(env, 'PATHEXT', platform));
+    const shellProbe = executableFromPath ? null : readShellProbe(command, userShell, env, platform, execFileSyncFn);
+    if (shellProbe?.shellPath) {
+        const mergedPath = mergePathValues(shellProbe.shellPath, getEnvValue(env, 'PATH', platform), platform);
+        if (mergedPath)
+            setEnvValue(env, 'PATH', mergedPath, platform);
+    }
+    const executable = shellProbe?.executablePath || executableFromPath || command;
     try {
         const realPath = fs.realpathSync(executable);
         const shebang = readShebang(realPath)?.toLowerCase() ?? '';
@@ -88,6 +110,66 @@ function quoteShellArg(value) {
         return "''";
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
+function mergePathValues(preferredPath, fallbackPath, platform) {
+    const delimiter = platform === 'win32' ? ';' : path.delimiter;
+    const seen = new Set();
+    const merged = [];
+    for (const source of [preferredPath, fallbackPath]) {
+        if (!source)
+            continue;
+        for (const entry of source.split(delimiter)) {
+            const trimmed = entry.trim();
+            if (!trimmed)
+                continue;
+            const key = platform === 'win32' ? trimmed.toLowerCase() : trimmed;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            merged.push(trimmed);
+        }
+    }
+    return merged.length > 0 ? merged.join(delimiter) : undefined;
+}
+function readShellProbe(command, userShell, env, platform, execFileSyncFn = execFileSync) {
+    if (platform === 'win32' || !userShell)
+        return null;
+    if (!command || command.includes('/') || command.includes('\\'))
+        return null;
+    const pathStartMarker = '__TERMSPEAK_PATH_START__';
+    const pathEndMarker = '__TERMSPEAK_PATH_END__';
+    const commandStartMarker = '__TERMSPEAK_COMMAND_START__';
+    const commandEndMarker = '__TERMSPEAK_COMMAND_END__';
+    const shellCommand = [
+        `printf '${pathStartMarker}%s${pathEndMarker}\\n' "$PATH"`,
+        `resolved=$(command -v ${quoteShellArg(command)} 2>/dev/null || true)`,
+        `printf '${commandStartMarker}%s${commandEndMarker}' "$resolved"`,
+    ].join('; ');
+    try {
+        const output = execFileSyncFn(userShell, ['-ic', shellCommand], {
+            encoding: 'utf8',
+            env: { ...env },
+            timeout: 3000,
+            maxBuffer: 64 * 1024,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const shellPath = output.match(new RegExp(`${pathStartMarker}([\\s\\S]*?)${pathEndMarker}`))?.[1]?.trim() || undefined;
+        const commandLines = output
+            .match(new RegExp(`${commandStartMarker}([\\s\\S]*?)${commandEndMarker}`))?.[1]
+            ?.split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean);
+        const executablePath = commandLines
+            ? [...commandLines].reverse().find((line) => line.includes('/') || line.includes('\\'))
+            : undefined;
+        if (!executablePath)
+            return shellPath ? { executablePath: '', shellPath } : null;
+        const resolvedPath = expandTilde(executablePath);
+        return isExecutable(resolvedPath, platform) ? { executablePath: resolvedPath, shellPath } : shellPath ? { executablePath: '', shellPath } : null;
+    }
+    catch {
+        return null;
+    }
+}
 function formatSpawnError(entry, error) {
     const errorMessage = error instanceof Error ? error.message : String(error ?? '');
     const errorCode = error && typeof error === 'object' && 'code' in error && typeof error.code === 'string' ? error.code : undefined;
@@ -96,7 +178,7 @@ function formatSpawnError(entry, error) {
             /posix_spawnp failed/i.test(errorMessage) ||
             /spawn .* ENOENT/i.test(errorMessage) ||
             /not found/i.test(errorMessage))) {
-        return new Error(`Could not start "${entry.label}". Command "${entry.command}" was not found in PATH. Install it or switch this provider to Shell command if it depends on a shell wrapper.`);
+        return new Error(`Could not start "${entry.label}". Command "${entry.command}" was not found in PATH. Install it, use an absolute path, set PATH in provider env, or switch this provider to Shell command if it depends on a shell wrapper.`);
     }
     if (error instanceof Error) {
         return new Error(`Could not start "${entry.label}": ${error.message}`);
@@ -132,6 +214,7 @@ export function createPtySpawner(options = {}) {
     const spawn = options.spawn ?? pty.spawn;
     const shell = options.shell ?? process.env.SHELL ?? '/bin/bash';
     const platform = options.platform ?? process.platform;
+    const execFileSyncFn = options.execFileSync ?? execFileSync;
     return ({ provider, cwd, config }) => {
         const entry = config.providers[provider];
         const command = resolveProviderCommand(config, provider, shell);
@@ -140,7 +223,7 @@ export function createPtySpawner(options = {}) {
             ...command.envOverrides,
         };
         const spawnTarget = command.executionMode === 'direct'
-            ? resolveDirectSpawnTarget(command.file, command.args, env, platform)
+            ? resolveDirectSpawnTarget(command.file, command.args, env, platform, shell, execFileSyncFn)
             : { file: command.file, args: command.args };
         try {
             return spawn(spawnTarget.file, spawnTarget.args, {

package/bin/termspeak-lib.mjs

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
 import { homedir } from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
@@ -31,6 +31,7 @@ Options:
   --no-open          Do not open the browser after the server starts (default)
   --config <path>    Path to the config file (default: ${DEFAULT_CONFIG_PATH})
   --cwd <path>       Default working directory for new sessions
+  --reset-config     Delete the selected local config file and exit
   --help, -h         Show this help message
   --version, -v      Show the current version
 `;
@@ -81,6 +82,11 @@ export function parseArgs(argv) {
       continue;
     }
 
+    if (arg === '--reset-config') {
+      options.resetConfig = true;
+      continue;
+    }
+
     if (arg === '--port' || arg.startsWith('--port=')) {
       const raw = arg.includes('=') ? arg.slice('--port='.length) : takeValue(arg, i++);
       const port = Number(raw);
@@ -115,6 +121,23 @@ export function parseArgs(argv) {
   return options;
 }
 
+export function resetConfigFile(configPath = DEFAULT_CONFIG_PATH) {
+  const resolvedPath = path.resolve(configPath);
+
+  if (!existsSync(resolvedPath)) {
+    return {
+      removed: false,
+      configPath: resolvedPath,
+    };
+  }
+
+  rmSync(resolvedPath, { force: true });
+  return {
+    removed: true,
+    configPath: resolvedPath,
+  };
+}
+
 export function openBrowser(url) {
   const platform = process.platform;
 
@@ -147,6 +170,16 @@ export async function main(argv = process.argv.slice(2)) {
     return;
   }
 
+  if (options.resetConfig) {
+    const result = resetConfigFile(options.configPath ?? DEFAULT_CONFIG_PATH);
+    console.log(
+      result.removed
+        ? `Deleted config file: ${result.configPath}`
+        : `Config file not found, nothing to reset: ${result.configPath}`,
+    );
+    return;
+  }
+
   if (!existsSync(SERVER_ENTRY)) {
     throw new Error('TermSpeak is not built yet. Run `npm run build` first.');
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promptmic",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Voice-first local UI for terminal-based AI coding assistants.",
   "license": "MIT",
   "keywords": [