pi-interactive-shell 0.3.0

package/scripts/install.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, cpSync, symlinkSync, unlinkSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = join(__dirname, "..");
+
+const EXTENSION_DIR = join(homedir(), ".pi", "agent", "extensions", "interactive-shell");
+const SKILL_DIR = join(homedir(), ".pi", "agent", "skills", "interactive-shell");
+
+function log(msg) {
+	console.log(`[pi-interactive-shell] ${msg}`);
+}
+
+function main() {
+	const pkg = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf-8"));
+	log(`Installing version ${pkg.version}...`);
+
+	// Create extension directory
+	log(`Creating ${EXTENSION_DIR}`);
+	mkdirSync(EXTENSION_DIR, { recursive: true });
+
+	// Files to copy
+	const files = [
+		"package.json",
+		"index.ts",
+		"config.ts",
+		"overlay-component.ts",
+		"pty-session.ts",
+		"session-manager.ts",
+		"README.md",
+		"SKILL.md",
+		"CHANGELOG.md",
+	];
+
+	// Copy files
+	for (const file of files) {
+		const src = join(packageRoot, file);
+		const dest = join(EXTENSION_DIR, file);
+		if (existsSync(src)) {
+			cpSync(src, dest);
+			log(`Copied ${file}`);
+		}
+	}
+
+	// Copy scripts directory
+	const scriptsDir = join(packageRoot, "scripts");
+	const destScriptsDir = join(EXTENSION_DIR, "scripts");
+	if (existsSync(scriptsDir)) {
+		mkdirSync(destScriptsDir, { recursive: true });
+		cpSync(scriptsDir, destScriptsDir, { recursive: true });
+		log("Copied scripts/");
+	}
+
+	// Run npm install in extension directory
+	log("Running npm install...");
+	try {
+		execSync("npm install", { cwd: EXTENSION_DIR, stdio: "inherit" });
+	} catch (error) {
+		log(`Warning: npm install failed: ${error.message}`);
+		log("You may need to run 'npm install' manually in the extension directory.");
+	}
+
+	// Create skill symlink
+	log(`Creating skill symlink at ${SKILL_DIR}`);
+	mkdirSync(SKILL_DIR, { recursive: true });
+	const skillLink = join(SKILL_DIR, "SKILL.md");
+	const skillTarget = join(EXTENSION_DIR, "SKILL.md");
+
+	try {
+		if (existsSync(skillLink)) {
+			unlinkSync(skillLink);
+		}
+		symlinkSync(skillTarget, skillLink);
+		log("Skill symlink created");
+	} catch (error) {
+		log(`Warning: Could not create skill symlink: ${error.message}`);
+		log(`You can create it manually: ln -sf ${skillTarget} ${skillLink}`);
+	}
+
+	log("");
+	log("Installation complete!");
+	log("");
+	log("Restart pi to load the extension.");
+	log("");
+	log("Usage:");
+	log('  interactive_shell({ command: \'pi "Fix all bugs"\', mode: "hands-free" })');
+	log("");
+}
+
+main();

package/session-manager.ts

@@ -0,0 +1,226 @@
+import { PtyTerminalSession } from "./pty-session.js";
+
+export interface BackgroundSession {
+	id: string;
+	name: string;
+	command: string;
+	reason?: string;
+	session: PtyTerminalSession;
+	startedAt: Date;
+}
+
+export interface ActiveSession {
+	id: string;
+	command: string;
+	write: (data: string) => void;
+	setUpdateInterval?: (intervalMs: number) => void;
+	setQuietThreshold?: (thresholdMs: number) => void;
+	startedAt: Date;
+}
+
+// Human-readable session slug generation
+const SLUG_ADJECTIVES = [
+	"amber", "brisk", "calm", "clear", "cool", "crisp", "dawn", "ember",
+	"fast", "fresh", "gentle", "keen", "kind", "lucky", "mellow", "mild",
+	"neat", "nimble", "nova", "quick", "quiet", "rapid", "sharp", "swift",
+	"tender", "tidy", "vivid", "warm", "wild", "young",
+];
+
+const SLUG_NOUNS = [
+	"atlas", "bloom", "breeze", "cedar", "cloud", "comet", "coral", "cove",
+	"crest", "delta", "dune", "ember", "falcon", "fjord", "glade", "haven",
+	"kelp", "lagoon", "meadow", "mist", "nexus", "orbit", "pine", "reef",
+	"ridge", "river", "sage", "shell", "shore", "summit", "trail", "zephyr",
+];
+
+function randomChoice<T>(arr: T[]): T {
+	return arr[Math.floor(Math.random() * arr.length)];
+}
+
+// Track used IDs to avoid collisions
+const usedIds = new Set<string>();
+
+export function generateSessionId(name?: string): string {
+	// If a custom name is provided, use simple counter approach
+	if (name) {
+		let counter = 1;
+		let id = name;
+		while (usedIds.has(id)) {
+			counter++;
+			id = `${name}-${counter}`;
+		}
+		usedIds.add(id);
+		return id;
+	}
+
+	// Generate human-readable slug
+	for (let attempt = 0; attempt < 20; attempt++) {
+		const adj = randomChoice(SLUG_ADJECTIVES);
+		const noun = randomChoice(SLUG_NOUNS);
+		const base = `${adj}-${noun}`;
+
+		if (!usedIds.has(base)) {
+			usedIds.add(base);
+			return base;
+		}
+
+		// Try with suffix
+		for (let i = 2; i <= 9; i++) {
+			const candidate = `${base}-${i}`;
+			if (!usedIds.has(candidate)) {
+				usedIds.add(candidate);
+				return candidate;
+			}
+		}
+	}
+
+	// Fallback: timestamp-based
+	const fallback = `shell-${Date.now().toString(36)}`;
+	usedIds.add(fallback);
+	return fallback;
+}
+
+export function releaseSessionId(id: string): void {
+	usedIds.delete(id);
+}
+
+// Derive a friendly display name from command (e.g., "pi Fix all bugs" -> "pi Fix all bugs")
+export function deriveSessionName(command: string): string {
+	const trimmed = command.trim();
+	if (trimmed.length <= 60) return trimmed;
+
+	// Truncate with ellipsis
+	return trimmed.slice(0, 57) + "...";
+}
+
+export class ShellSessionManager {
+	private sessions = new Map<string, BackgroundSession>();
+	private exitWatchers = new Map<string, NodeJS.Timeout>();
+	private cleanupTimers = new Map<string, NodeJS.Timeout>();
+	private activeSessions = new Map<string, ActiveSession>();
+
+	// Active hands-free session management
+	registerActive(
+		id: string,
+		command: string,
+		write: (data: string) => void,
+		setUpdateInterval?: (intervalMs: number) => void,
+		setQuietThreshold?: (thresholdMs: number) => void,
+	): void {
+		this.activeSessions.set(id, {
+			id,
+			command,
+			write,
+			setUpdateInterval,
+			setQuietThreshold,
+			startedAt: new Date(),
+		});
+	}
+
+	unregisterActive(id: string): void {
+		this.activeSessions.delete(id);
+		releaseSessionId(id);
+	}
+
+	getActive(id: string): ActiveSession | undefined {
+		return this.activeSessions.get(id);
+	}
+
+	writeToActive(id: string, data: string): boolean {
+		const session = this.activeSessions.get(id);
+		if (!session) return false;
+		session.write(data);
+		return true;
+	}
+
+	setActiveUpdateInterval(id: string, intervalMs: number): boolean {
+		const session = this.activeSessions.get(id);
+		if (!session?.setUpdateInterval) return false;
+		session.setUpdateInterval(intervalMs);
+		return true;
+	}
+
+	setActiveQuietThreshold(id: string, thresholdMs: number): boolean {
+		const session = this.activeSessions.get(id);
+		if (!session?.setQuietThreshold) return false;
+		session.setQuietThreshold(thresholdMs);
+		return true;
+	}
+
+	listActive(): ActiveSession[] {
+		return Array.from(this.activeSessions.values());
+	}
+
+	// Background session management
+	add(command: string, session: PtyTerminalSession, name?: string, reason?: string): string {
+		const id = generateSessionId(name);
+		this.sessions.set(id, {
+			id,
+			name: name || deriveSessionName(command),
+			command,
+			reason,
+			session,
+			startedAt: new Date(),
+		});
+
+		session.setEventHandlers({});
+
+		const checkExit = setInterval(() => {
+			if (session.exited) {
+				clearInterval(checkExit);
+				this.exitWatchers.delete(id);
+				const cleanupTimer = setTimeout(() => {
+					this.cleanupTimers.delete(id);
+					this.remove(id);
+				}, 30000);
+				this.cleanupTimers.set(id, cleanupTimer);
+			}
+		}, 1000);
+		this.exitWatchers.set(id, checkExit);
+
+		return id;
+	}
+
+	get(id: string): BackgroundSession | undefined {
+		// Cancel auto-cleanup timer when session is being reattached
+		const cleanupTimer = this.cleanupTimers.get(id);
+		if (cleanupTimer) {
+			clearTimeout(cleanupTimer);
+			this.cleanupTimers.delete(id);
+		}
+		return this.sessions.get(id);
+	}
+
+	remove(id: string): void {
+		const watcher = this.exitWatchers.get(id);
+		if (watcher) {
+			clearInterval(watcher);
+			this.exitWatchers.delete(id);
+		}
+
+		const cleanupTimer = this.cleanupTimers.get(id);
+		if (cleanupTimer) {
+			clearTimeout(cleanupTimer);
+			this.cleanupTimers.delete(id);
+		}
+
+		const session = this.sessions.get(id);
+		if (session) {
+			session.session.dispose();
+			this.sessions.delete(id);
+			releaseSessionId(id);
+		}
+	}
+
+	list(): BackgroundSession[] {
+		return Array.from(this.sessions.values());
+	}
+
+	killAll(): void {
+		for (const [id] of this.sessions) {
+			this.remove(id);
+		}
+	}
+}
+
+export const sessionManager = new ShellSessionManager();