making RPC mode more responsive and stable for Devtool clients

Author: igorcosta

src/index.ts

@@ -138,8 +138,16 @@ program
   .option('--unrestricted', 'Run without any approval prompts (use with caution)', false)
   .option('--restricted', 'Deny all dangerous operations automatically', false)
   .option('--auto-skill', 'Auto-generate skills based on project analysis', false)
+  .option('--skill-install [skill-name]', 'Install a community skill (opens browser if no name)')
+  .option('--project', 'Install skill to project level (with --skill-install)', false)
   .option('--mode <mode>', 'Run mode: interactive (default) or rpc', 'interactive')
-  .action(async (opts: CLIOptions & { mode?: string }) => {
+  .action(async (opts: CLIOptions & { mode?: string; skillInstall?: string | boolean; project?: boolean }) => {
+    // Handle --skill-install flag
+    if (opts.skillInstall !== undefined) {
+      await runSkillInstall(opts);
+      return;
+    }
+
     if (opts.mode === 'rpc') {
       await runRpcMode(opts);
     } else {
@@ -327,4 +335,31 @@ function printWelcome(runtime: AgentRuntime, authUser?: AuthUser): void {
   console.log();
 }
 
+/**
+ * Handle --skill-install flag for installing community skills
+ */
+async function runSkillInstall(opts: CLIOptions & { skillInstall?: string | boolean; project?: boolean }): Promise<void> {
+  const config = await loadConfig(opts.config);
+  const workspaceRoot = resolveWorkspaceRoot(config, opts.path);
+
+  // Import skill install dependencies
+  const { SkillsRegistry } = await import('./skills/SkillsRegistry.js');
+  const { AUTOHAND_PATHS } = await import('./constants.js');
+  const { skillsInstall } = await import('./commands/skills-install.js');
+
+  // Initialize skills registry
+  const skillsRegistry = new SkillsRegistry(AUTOHAND_PATHS.skills);
+  await skillsRegistry.initialize();
+  await skillsRegistry.setWorkspace(workspaceRoot);
+
+  // Determine skill name (if provided)
+  const skillName = typeof opts.skillInstall === 'string' ? opts.skillInstall : undefined;
+
+  // Run the install command
+  await skillsInstall({
+    skillsRegistry,
+    workspaceRoot,
+  }, skillName);
+}
+
 program.parseAsync();

src/modes/rpc/adapter.ts

@@ -43,6 +43,7 @@ export class RPCAdapter {
   private imageManager: ImageManager | null = null;
   private sessionId: string | null = null;
   private currentTurnId: string | null = null;
+  private turnStartTime: number | null = null;
   private currentMessageId: string | null = null;
   private currentMessageContent = '';
   private pendingPermissions = new Map<string, PendingPermission>();
@@ -139,6 +140,7 @@ export class RPCAdapter {
 
     // Start a new turn
     this.currentTurnId = generateId('turn');
+    this.turnStartTime = Date.now();
     writeNotification(RPC_NOTIFICATIONS.TURN_START, {
       turnId: this.currentTurnId,
       timestamp: createTimestamp(),
@@ -243,7 +245,49 @@ export class RPCAdapter {
       try {
         // Debug: log instruction being executed
         process.stderr.write(`[RPC DEBUG] Executing instruction: ${instruction.substring(0, 100)}\n`);
-        success = await this.agent.runInstruction(instruction);
+
+        // Check if it's a slash command and handle it directly
+        if (this.agent.isSlashCommand(instruction)) {
+          const { command, args } = this.agent.parseSlashCommand(instruction);
+          process.stderr.write(`[RPC DEBUG] Handling slash command: ${command}, args: ${JSON.stringify(args)}\n`);
+
+          // First check if the command is supported
+          if (this.agent.isSlashCommandSupported(command)) {
+            const result = await this.agent.handleSlashCommand(command, args);
+            if (result !== null) {
+              // Slash command returned data
+              this.currentMessageContent = result;
+              writeNotification(RPC_NOTIFICATIONS.MESSAGE_UPDATE, {
+                messageId: this.currentMessageId,
+                delta: result,
+                timestamp: createTimestamp(),
+              });
+            } else {
+              // Command was handled but returned null (output went to console)
+              // This is success - the command was executed
+              this.currentMessageContent = `Command ${command} executed.`;
+              writeNotification(RPC_NOTIFICATIONS.MESSAGE_UPDATE, {
+                messageId: this.currentMessageId,
+                delta: this.currentMessageContent,
+                timestamp: createTimestamp(),
+              });
+            }
+            success = true;
+          } else {
+            // Command not found
+            this.currentMessageContent = `Unknown command: ${command}. Type /help for available commands.`;
+            writeNotification(RPC_NOTIFICATIONS.MESSAGE_UPDATE, {
+              messageId: this.currentMessageId,
+              delta: this.currentMessageContent,
+              timestamp: createTimestamp(),
+            });
+            success = false;
+          }
+        } else {
+          // Not a slash command - run as regular instruction via LLM
+          success = await this.agent.runInstruction(instruction);
+        }
+
         process.stderr.write(`[RPC DEBUG] Instruction completed, success=${success}, content length=${this.currentMessageContent.length}\n`);
       } catch (err) {
         const errorMessage = err instanceof Error ? err.message : String(err);
@@ -268,29 +312,39 @@ export class RPCAdapter {
         timestamp: createTimestamp(),
       });
 
-      // End turn with context percent
+      // End turn with stats
+      const durationMs = this.turnStartTime ? Date.now() - this.turnStartTime : undefined;
+      const snapshot = this.agent?.getStatusSnapshot();
       writeNotification(RPC_NOTIFICATIONS.TURN_END, {
         turnId: this.currentTurnId!,
         timestamp: createTimestamp(),
         contextPercent: this.contextPercent,
+        tokensUsed: snapshot?.tokensUsed,
+        durationMs,
       });
 
       this.status = 'idle';
       this.currentTurnId = null;
+      this.turnStartTime = null;
       this.currentMessageId = null;
       this.abortController = null;
 
       return { success };
     } catch (error) {
-      // End turn on error with context percent
+      // End turn on error with stats
+      const durationMs = this.turnStartTime ? Date.now() - this.turnStartTime : undefined;
+      const snapshot = this.agent?.getStatusSnapshot();
       writeNotification(RPC_NOTIFICATIONS.TURN_END, {
         turnId: this.currentTurnId!,
         timestamp: createTimestamp(),
         contextPercent: this.contextPercent,
+        tokensUsed: snapshot?.tokensUsed,
+        durationMs,
       });
 
       this.status = 'idle';
       this.currentTurnId = null;
+      this.turnStartTime = null;
       this.currentMessageId = null;
       this.abortController = null;
 
@@ -330,15 +384,20 @@ export class RPCAdapter {
 
       // End turn if one is in progress
       if (this.currentTurnId) {
+        const durationMs = this.turnStartTime ? Date.now() - this.turnStartTime : undefined;
+        const snapshot = this.agent?.getStatusSnapshot();
         writeNotification(RPC_NOTIFICATIONS.TURN_END, {
           turnId: this.currentTurnId,
           timestamp: createTimestamp(),
           contextPercent: this.contextPercent,
+          tokensUsed: snapshot?.tokensUsed,
+          durationMs,
         });
       }
 
       // Reset state
       this.currentTurnId = null;
+      this.turnStartTime = null;
       this.currentMessageId = null;
       this.currentMessageContent = '';
       this.abortController = null;

src/modes/rpc/types.ts

@@ -228,6 +228,9 @@ export interface TurnStartParams {
 export interface TurnEndParams {
   turnId: string;
   timestamp: string;
+  tokensUsed?: number;
+  durationMs?: number;
+  contextPercent?: number;
 }
 
 export interface MessageStartParams {