promptmic 0.1.0

package/bin/termspeak-lib.mjs

@@ -0,0 +1,189 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const ROOT_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const SERVER_ENTRY = path.join(ROOT_DIR, 'apps/server/dist/index.js');
+const DEFAULT_CONFIG_PATH = path.join(homedir(), '.term-speak', 'config.json');
+
+export function readVersion() {
+  try {
+    const packageJson = JSON.parse(readFileSync(path.join(ROOT_DIR, 'package.json'), 'utf-8'));
+    return typeof packageJson.version === 'string' ? packageJson.version : '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+export function getHelpText() {
+  return `TermSpeak
+
+Usage:
+  termspeak [options]
+
+Options:
+  --port <number>    Port to bind the local server (default: 3001)
+  --host <host>      Host to bind the local server (default: 127.0.0.1)
+  --allow-remote     Allow binding to non-local hosts and disable local-only protections
+  --open             Open the browser after the server starts
+  --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
+  --help, -h         Show this help message
+  --version, -v      Show the current version
+`;
+}
+
+export function printHelp() {
+  console.log(getHelpText());
+}
+
+export function parseArgs(argv) {
+  const options = {
+    open: false,
+  };
+
+  const takeValue = (flag, index) => {
+    const value = argv[index + 1];
+    if (!value || value.startsWith('-')) {
+      throw new Error(`Missing value for ${flag}.`);
+    }
+    return value;
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+      continue;
+    }
+
+    if (arg === '--version' || arg === '-v') {
+      options.version = true;
+      continue;
+    }
+
+    if (arg === '--open') {
+      options.open = true;
+      continue;
+    }
+
+    if (arg === '--allow-remote') {
+      options.allowRemote = true;
+      continue;
+    }
+
+    if (arg === '--no-open') {
+      options.open = false;
+      continue;
+    }
+
+    if (arg === '--port' || arg.startsWith('--port=')) {
+      const raw = arg.includes('=') ? arg.slice('--port='.length) : takeValue(arg, i++);
+      const port = Number(raw);
+      if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+        throw new Error(`Invalid port: ${raw}`);
+      }
+      options.port = port;
+      continue;
+    }
+
+    if (arg === '--host' || arg.startsWith('--host=')) {
+      const host = arg.includes('=') ? arg.slice('--host='.length) : takeValue(arg, i++);
+      options.host = host;
+      continue;
+    }
+
+    if (arg === '--config' || arg.startsWith('--config=')) {
+      const configPath = arg.includes('=') ? arg.slice('--config='.length) : takeValue(arg, i++);
+      options.configPath = path.resolve(configPath);
+      continue;
+    }
+
+    if (arg === '--cwd' || arg.startsWith('--cwd=')) {
+      const cwd = arg.includes('=') ? arg.slice('--cwd='.length) : takeValue(arg, i++);
+      options.cwd = path.resolve(cwd);
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+}
+
+export function openBrowser(url) {
+  const platform = process.platform;
+
+  if (platform === 'darwin') {
+    const child = spawn('open', [url], { detached: true, stdio: 'ignore' });
+    child.unref();
+    return;
+  }
+
+  if (platform === 'win32') {
+    const child = spawn('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' });
+    child.unref();
+    return;
+  }
+
+  const child = spawn('xdg-open', [url], { detached: true, stdio: 'ignore' });
+  child.unref();
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const options = parseArgs(argv);
+
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  if (options.version) {
+    console.log(readVersion());
+    return;
+  }
+
+  if (!existsSync(SERVER_ENTRY)) {
+    throw new Error('TermSpeak is not built yet. Run `npm run build` first.');
+  }
+
+  const { startServer } = await import(SERVER_ENTRY);
+  const started = await startServer({
+    port: options.port,
+    host: options.host,
+    workdir: options.cwd,
+    configPath: options.configPath,
+    preferUserConfig: !options.configPath,
+    allowRemote: options.allowRemote,
+  });
+
+  console.log(`TermSpeak running at ${started.url}`);
+  console.log(`Config file: ${started.configPath}`);
+  console.log('Press Ctrl+C to stop.');
+
+  if (options.open) {
+    openBrowser(started.url);
+  }
+
+  const stop = async () => {
+    process.off('SIGINT', handleSigint);
+    process.off('SIGTERM', handleSigterm);
+    await started.close();
+    process.exit(0);
+  };
+
+  const handleSigint = () => {
+    void stop();
+  };
+
+  const handleSigterm = () => {
+    void stop();
+  };
+
+  process.on('SIGINT', handleSigint);
+  process.on('SIGTERM', handleSigterm);
+}

package/bin/termspeak.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { main } from './termspeak-lib.mjs';
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : 'Unknown CLI error.';
+  console.error(`[term-speak] ${message}`);
+  process.exit(1);
+});

package/config.example.json

@@ -0,0 +1,21 @@
+{
+  "providers": {
+    "claude": {
+      "label": "Claude Code CLI",
+      "executionMode": "direct",
+      "command": "claude",
+      "args": [],
+      "env": {
+        "CLAUDE_CONFIG_DIR": "~/.claude"
+      }
+    },
+    "codex": {
+      "label": "Codex CLI",
+      "executionMode": "direct",
+      "command": "codex",
+      "args": [],
+      "env": {}
+    }
+  },
+  "defaultProvider": "claude"
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "promptmic",
+  "version": "0.1.0",
+  "description": "Voice-first local UI for terminal-based AI coding assistants.",
+  "license": "MIT",
+  "keywords": [
+    "ai",
+    "assistant",
+    "cli",
+    "voice",
+    "terminal",
+    "pty",
+    "codex",
+    "claude",
+    "aider"
+  ],
+  "homepage": "https://github.com/lucasaclima03/term-speak#readme",
+  "bugs": {
+    "url": "https://github.com/lucasaclima03/term-speak/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lucasaclima03/term-speak.git"
+  },
+  "bin": {
+    "promptmic": "bin/termspeak.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "bin/termspeak.mjs",
+    "bin/termspeak-lib.mjs",
+    "apps/server/dist",
+    "apps/web/dist",
+    "packages/shared/dist",
+    "LICENSE",
+    "README.md",
+    "config.example.json"
+  ],
+  "workspaces": [
+    "apps/server",
+    "apps/web",
+    "packages/*"
+  ],
+  "scripts": {
+    "dev": "npm run build -w packages/shared && concurrently -n shared,server,web -c magenta,cyan,green \"npm run dev -w packages/shared\" \"npm run dev -w apps/server\" \"npm run dev -w apps/web\"",
+    "dev:shared": "npm run dev -w packages/shared",
+    "dev:server": "npm run dev -w apps/server",
+    "dev:web": "npm run dev -w apps/web",
+    "clean": "rm -rf apps/server/dist apps/web/dist packages/shared/dist",
+    "build": "npm run build -w packages/shared && npm run build -w apps/server && npm run build -w apps/web",
+    "test": "npm run build -w packages/shared && vitest run",
+    "test:watch": "npm run build -w packages/shared && vitest",
+    "prepack": "npm run clean && npm run build",
+    "start": "node ./bin/termspeak.mjs",
+    "start:repo": "node ./bin/termspeak.mjs --config ./config.json",
+    "start:open": "node ./bin/termspeak.mjs --open"
+  },
+  "dependencies": {
+    "express": "^4.21.2",
+    "node-pty": "^1.1.0-beta34",
+    "ws": "^8.18.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "concurrently": "^9.1.2",
+    "vitest": "^4.1.0"
+  }
+}

package/packages/shared/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { providerExecutionModeSchema, providerEntrySchema, configSchema, type ProviderExecutionMode, type ProviderEntry, type Config, type ProviderInfo, type ProviderConfig, type FullConfig, type ApiInfo, } from './provider.js';
+export { startSessionSchema, inputSchema, resizeSchema, stopSessionSchema, wsCommandSchema, sessionStartedSchema, outputSchema, sessionExitSchema, errorSchema, wsEventSchema, type StartSession, type Input, type Resize, type StopSession, type WsCommand, type SessionStarted, type Output, type SessionExit, type WsError, type WsEvent, } from './ws-messages.js';

package/packages/shared/dist/index.js

@@ -0,0 +1,2 @@
+export { providerExecutionModeSchema, providerEntrySchema, configSchema, } from './provider.js';
+export { startSessionSchema, inputSchema, resizeSchema, stopSessionSchema, wsCommandSchema, sessionStartedSchema, outputSchema, sessionExitSchema, errorSchema, wsEventSchema, } from './ws-messages.js';

package/packages/shared/dist/provider.d.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+export declare const providerExecutionModeSchema: z.ZodEnum<["direct", "shell"]>;
+export declare const providerEntrySchema: z.ZodObject<{
+    label: z.ZodString;
+    executionMode: z.ZodDefault<z.ZodEnum<["direct", "shell"]>>;
+    command: z.ZodString;
+    args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    executionMode: "direct" | "shell";
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+}, {
+    label: string;
+    command: string;
+    executionMode?: "direct" | "shell" | undefined;
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+}>;
+export declare const configSchema: z.ZodObject<{
+    providers: z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodString;
+        executionMode: z.ZodDefault<z.ZodEnum<["direct", "shell"]>>;
+        command: z.ZodString;
+        args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        executionMode: "direct" | "shell";
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+    }, {
+        label: string;
+        command: string;
+        executionMode?: "direct" | "shell" | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+    }>>;
+    defaultProvider: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    providers: Record<string, {
+        label: string;
+        executionMode: "direct" | "shell";
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+    }>;
+    defaultProvider?: string | undefined;
+}, {
+    providers: Record<string, {
+        label: string;
+        command: string;
+        executionMode?: "direct" | "shell" | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+    }>;
+    defaultProvider?: string | undefined;
+}>;
+export type ProviderEntry = z.infer<typeof providerEntrySchema>;
+export type Config = z.infer<typeof configSchema>;
+export type ProviderExecutionMode = z.infer<typeof providerExecutionModeSchema>;
+export type ProviderInfo = {
+    id: string;
+    label: string;
+};
+export type ProviderConfig = {
+    label: string;
+    executionMode: ProviderExecutionMode;
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+};
+export type FullConfig = {
+    providers: Record<string, ProviderConfig>;
+    defaultProvider?: string;
+};
+export type ApiInfo = {
+    cwd: string;
+    home: string;
+    providers: ProviderInfo[];
+    defaultProvider: string;
+};

package/packages/shared/dist/provider.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export const providerExecutionModeSchema = z.enum(['direct', 'shell']);
+export const providerEntrySchema = z.object({
+    label: z.string().min(1),
+    executionMode: providerExecutionModeSchema.default('shell'),
+    command: z.string().min(1),
+    args: z.array(z.string()).default([]),
+    env: z.record(z.string(), z.string()).default({}),
+});
+export const configSchema = z.object({
+    providers: z.record(z.string().regex(/^[a-z0-9-]+$/), providerEntrySchema),
+    defaultProvider: z.string().optional(),
+});

package/packages/shared/dist/ws-messages.d.ts

@@ -0,0 +1,219 @@
+import { z } from 'zod';
+export declare const startSessionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"start_session">;
+    provider: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "start_session";
+    provider: string;
+    cwd?: string | undefined;
+}, {
+    type: "start_session";
+    provider: string;
+    cwd?: string | undefined;
+}>;
+export declare const inputSchema: z.ZodObject<{
+    type: z.ZodLiteral<"input">;
+    sessionId: z.ZodString;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "input";
+    sessionId: string;
+    data: string;
+}, {
+    type: "input";
+    sessionId: string;
+    data: string;
+}>;
+export declare const resizeSchema: z.ZodObject<{
+    type: z.ZodLiteral<"resize">;
+    sessionId: z.ZodString;
+    cols: z.ZodNumber;
+    rows: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "resize";
+    sessionId: string;
+    cols: number;
+    rows: number;
+}, {
+    type: "resize";
+    sessionId: string;
+    cols: number;
+    rows: number;
+}>;
+export declare const stopSessionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"stop_session">;
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "stop_session";
+    sessionId: string;
+}, {
+    type: "stop_session";
+    sessionId: string;
+}>;
+export declare const wsCommandSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"start_session">;
+    provider: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "start_session";
+    provider: string;
+    cwd?: string | undefined;
+}, {
+    type: "start_session";
+    provider: string;
+    cwd?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"input">;
+    sessionId: z.ZodString;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "input";
+    sessionId: string;
+    data: string;
+}, {
+    type: "input";
+    sessionId: string;
+    data: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"resize">;
+    sessionId: z.ZodString;
+    cols: z.ZodNumber;
+    rows: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "resize";
+    sessionId: string;
+    cols: number;
+    rows: number;
+}, {
+    type: "resize";
+    sessionId: string;
+    cols: number;
+    rows: number;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"stop_session">;
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "stop_session";
+    sessionId: string;
+}, {
+    type: "stop_session";
+    sessionId: string;
+}>]>;
+export type StartSession = z.infer<typeof startSessionSchema>;
+export type Input = z.infer<typeof inputSchema>;
+export type Resize = z.infer<typeof resizeSchema>;
+export type StopSession = z.infer<typeof stopSessionSchema>;
+export type WsCommand = z.infer<typeof wsCommandSchema>;
+export declare const sessionStartedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"session_started">;
+    sessionId: z.ZodString;
+    provider: z.ZodString;
+    cwd: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "session_started";
+    provider: string;
+    cwd: string;
+    sessionId: string;
+}, {
+    type: "session_started";
+    provider: string;
+    cwd: string;
+    sessionId: string;
+}>;
+export declare const outputSchema: z.ZodObject<{
+    type: z.ZodLiteral<"output">;
+    sessionId: z.ZodString;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "output";
+    sessionId: string;
+    data: string;
+}, {
+    type: "output";
+    sessionId: string;
+    data: string;
+}>;
+export declare const sessionExitSchema: z.ZodObject<{
+    type: z.ZodLiteral<"session_exit">;
+    sessionId: z.ZodString;
+    exitCode: z.ZodNumber;
+    signal: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "session_exit";
+    sessionId: string;
+    exitCode: number;
+    signal: number;
+}, {
+    type: "session_exit";
+    sessionId: string;
+    exitCode: number;
+    signal: number;
+}>;
+export declare const errorSchema: z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "error";
+}, {
+    message: string;
+    type: "error";
+}>;
+export declare const wsEventSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"session_started">;
+    sessionId: z.ZodString;
+    provider: z.ZodString;
+    cwd: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "session_started";
+    provider: string;
+    cwd: string;
+    sessionId: string;
+}, {
+    type: "session_started";
+    provider: string;
+    cwd: string;
+    sessionId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"output">;
+    sessionId: z.ZodString;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "output";
+    sessionId: string;
+    data: string;
+}, {
+    type: "output";
+    sessionId: string;
+    data: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"session_exit">;
+    sessionId: z.ZodString;
+    exitCode: z.ZodNumber;
+    signal: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "session_exit";
+    sessionId: string;
+    exitCode: number;
+    signal: number;
+}, {
+    type: "session_exit";
+    sessionId: string;
+    exitCode: number;
+    signal: number;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "error";
+}, {
+    message: string;
+    type: "error";
+}>]>;
+export type SessionStarted = z.infer<typeof sessionStartedSchema>;
+export type Output = z.infer<typeof outputSchema>;
+export type SessionExit = z.infer<typeof sessionExitSchema>;
+export type WsError = z.infer<typeof errorSchema>;
+export type WsEvent = z.infer<typeof wsEventSchema>;

package/packages/shared/dist/ws-messages.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+// ── Client → Server (commands) ──────────────────────────────────────
+export const startSessionSchema = z.object({
+    type: z.literal('start_session'),
+    provider: z.string(),
+    cwd: z.string().optional(),
+});
+export const inputSchema = z.object({
+    type: z.literal('input'),
+    sessionId: z.string(),
+    data: z.string(),
+});
+export const resizeSchema = z.object({
+    type: z.literal('resize'),
+    sessionId: z.string(),
+    cols: z.number().int().positive(),
+    rows: z.number().int().positive(),
+});
+export const stopSessionSchema = z.object({
+    type: z.literal('stop_session'),
+    sessionId: z.string(),
+});
+export const wsCommandSchema = z.discriminatedUnion('type', [
+    startSessionSchema,
+    inputSchema,
+    resizeSchema,
+    stopSessionSchema,
+]);
+// ── Server → Client (events) ───────────────────────────────────────
+export const sessionStartedSchema = z.object({
+    type: z.literal('session_started'),
+    sessionId: z.string(),
+    provider: z.string(),
+    cwd: z.string(),
+});
+export const outputSchema = z.object({
+    type: z.literal('output'),
+    sessionId: z.string(),
+    data: z.string(),
+});
+export const sessionExitSchema = z.object({
+    type: z.literal('session_exit'),
+    sessionId: z.string(),
+    exitCode: z.number(),
+    signal: z.number(),
+});
+export const errorSchema = z.object({
+    type: z.literal('error'),
+    message: z.string(),
+});
+export const wsEventSchema = z.discriminatedUnion('type', [
+    sessionStartedSchema,
+    outputSchema,
+    sessionExitSchema,
+    errorSchema,
+]);