sessioncast-cli 2.0.9 → 2.2.0

package/dist/agent/api-client.d.ts

@@ -20,6 +20,13 @@ export declare class ApiWebSocketClient {
     private handleLlmChat;
     private handleSendKeys;
     private handleListSessions;
+    /**
+     * Handle capability_request from relay — evaluate each requested capability
+     * against the agent's config and respond with capability_grant.
+     *
+     * Config values: true = auto-grant, false = auto-deny, 'ask' = deny + log notice
+     */
+    private handleCapabilityRequest;
     private sendApiResponse;
     private send;
     private scheduleReconnect;

package/dist/agent/api-client.js

@@ -138,6 +138,9 @@ class ApiWebSocketClient {
             case 'list_sessions':
                 await this.handleListSessions(message);
                 break;
+            case 'capability_request':
+                this.handleCapabilityRequest(message);
+                break;
         }
     }
     async handleExec(message) {
@@ -212,7 +215,18 @@ class ApiWebSocketClient {
         try {
             console.log('[API] list_sessions');
             const sessions = tmux.listSessions();
-            this.sendApiResponse(meta.requestId, { sessions });
+            const enriched = sessions.map(s => {
+                const cwd = tmux.getPaneCwd(s.name);
+                const git = cwd ? tmux.getGitInfo(cwd) : null;
+                return {
+                    ...s,
+                    cwd: cwd || undefined,
+                    gitBranch: git?.branch || undefined,
+                    gitRemote: git?.remote || undefined,
+                    gitRepo: git?.repo || undefined
+                };
+            });
+            this.sendApiResponse(meta.requestId, { sessions: enriched });
         }
         catch (error) {
             this.sendApiResponse(meta.requestId, {
@@ -221,6 +235,47 @@ class ApiWebSocketClient {
             });
         }
     }
+    /**
+     * Handle capability_request from relay — evaluate each requested capability
+     * against the agent's config and respond with capability_grant.
+     *
+     * Config values: true = auto-grant, false = auto-deny, 'ask' = deny + log notice
+     */
+    handleCapabilityRequest(message) {
+        const meta = message.meta;
+        if (!meta)
+            return;
+        const from = meta.from;
+        const requestedStr = meta.capabilities || '';
+        const requested = requestedStr.split(',').map(s => s.trim()).filter(Boolean);
+        const capConfig = this.apiConfig.capabilities || {};
+        const granted = [];
+        const denied = [];
+        for (const cap of requested) {
+            const setting = capConfig[cap];
+            if (setting === true) {
+                granted.push(cap);
+            }
+            else if (setting === 'ask') {
+                // Future: interactive prompt. For now, deny and log notice.
+                console.log(`[API] Capability '${cap}' requires user consent (configured as 'ask'). Denying by default.`);
+                denied.push(cap);
+            }
+            else if (setting === false || setting === undefined) {
+                // Explicitly denied or not configured → deny
+                denied.push(cap);
+            }
+        }
+        console.log(`[API] Capability request from SDK: requested=[${requested}], granted=[${granted}], denied=[${denied}]`);
+        this.send({
+            type: 'capability_grant',
+            meta: {
+                from: from || '',
+                granted: granted.join(','),
+                denied: denied.join(',')
+            }
+        });
+    }
     sendApiResponse(requestId, response) {
         this.send({
             type: 'api_response',

package/dist/agent/debug.d.ts

@@ -0,0 +1,3 @@
+export declare function setDebug(enabled: boolean): void;
+export declare function isDebug(): boolean;
+export declare function debugLog(tag: string, ...args: any[]): void;

package/dist/agent/debug.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDebug = setDebug;
+exports.isDebug = isDebug;
+exports.debugLog = debugLog;
+let debugEnabled = false;
+function setDebug(enabled) {
+    debugEnabled = enabled;
+}
+function isDebug() {
+    return debugEnabled;
+}
+function debugLog(tag, ...args) {
+    if (debugEnabled) {
+        console.log(`[DEBUG][${tag}]`, ...args);
+    }
+}

package/dist/agent/runner.js

@@ -184,7 +184,7 @@ class AgentRunner {
         const handler = new session_handler_1.TmuxSessionHandler({
             config: this.config,
             tmuxSession,
-            onCreateSession: (name) => this.createTmuxSession(name)
+            onCreateSession: (name, workingDir) => this.createTmuxSession(name, workingDir)
         });
         this.handlers.set(tmuxSession, handler);
         handler.start();
@@ -199,7 +199,7 @@ class AgentRunner {
             console.log(`Stopped handler for session: ${this.config.machineId}/${tmuxSession}`);
         }
     }
-    createTmuxSession(sessionName) {
+    createTmuxSession(sessionName, workingDir) {
         // Sanitize session name
         const sanitized = sessionName.replace(/[^a-zA-Z0-9_-]/g, '_');
         if (!sanitized) {
@@ -210,8 +210,8 @@ class AgentRunner {
             console.warn(`Session already exists: ${sanitized}`);
             return;
         }
-        console.log(`Creating new tmux session: ${sanitized}`);
-        if (tmux.createSession(sanitized)) {
+        console.log(`Creating new tmux session: ${sanitized}${workingDir ? ` (cwd: ${workingDir})` : ''}`);
+        if (tmux.createSession(sanitized, workingDir)) {
             console.log(`Successfully created tmux session: ${sanitized}`);
             // Force immediate scan
             this.scanAndUpdateSessions();

package/dist/agent/session-handler.d.ts

@@ -2,7 +2,7 @@ import { AgentConfig } from './types';
 interface SessionHandlerOptions {
     config: AgentConfig;
     tmuxSession: string;
-    onCreateSession?: (name: string) => void;
+    onCreateSession?: (name: string, workingDir?: string) => void;
 }
 export declare class TmuxSessionHandler {
     private config;
@@ -17,6 +17,8 @@ export declare class TmuxSessionHandler {
     private captureTimer;
     private lastPaneIds;
     private lastPaneScreens;
+    private currentMetaJson;
+    private metaCheckTimer;
     private pendingUploads;
     private uploadDir;
     constructor(options: SessionHandlerOptions);
@@ -50,6 +52,10 @@ export declare class TmuxSessionHandler {
      * Get content type from file extension
      */
     private getContentType;
+    private handleCreateWorktree;
+    private startMetaTracking;
+    private stopMetaTracking;
+    private checkAndSendMeta;
     private handleKeys;
     private startScreenCapture;
     private stopScreenCapture;

package/dist/agent/session-handler.js

@@ -38,7 +38,9 @@ const websocket_1 = require("./websocket");
 const tmux = __importStar(require("./tmux"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
 const sentry_1 = require("../sentry");
+const debug_1 = require("./debug");
 // Capture intervals
 const CAPTURE_INTERVAL_ACTIVE_MS = 50;
 const CAPTURE_INTERVAL_IDLE_MS = 200;
@@ -46,6 +48,7 @@ const ACTIVE_THRESHOLD_MS = 2000;
 const FORCE_SEND_INTERVAL_MS = 10000;
 const USE_COMPRESSION = true;
 const MIN_COMPRESS_SIZE = 512;
+const META_CHECK_INTERVAL_MS = 15000;
 class TmuxSessionHandler {
     constructor(options) {
         this.wsClient = null;
@@ -57,6 +60,9 @@ class TmuxSessionHandler {
         // Multi-pane tracking
         this.lastPaneIds = '';
         this.lastPaneScreens = new Map();
+        // Metadata tracking (cwd + git info)
+        this.currentMetaJson = '';
+        this.metaCheckTimer = null;
         // File upload handling
         this.pendingUploads = new Map();
         this.uploadDir = process.cwd(); // Default to current working directory
@@ -88,6 +94,7 @@ class TmuxSessionHandler {
         this.wsClient.on('connected', () => {
             console.log(`[${this.tmuxSession}] Connected to relay`);
             this.startScreenCapture();
+            this.startMetaTracking();
         });
         this.wsClient.on('disconnected', ({ code, reason }) => {
             console.log(`[${this.tmuxSession}] Disconnected: code=${code}, reason=${reason}`);
@@ -127,6 +134,9 @@ class TmuxSessionHandler {
         this.wsClient.on('uploadFile', (chunk) => {
             this.handleUploadChunk(chunk);
         });
+        this.wsClient.on('createWorktree', (branch) => {
+            this.handleCreateWorktree(branch);
+        });
         this.wsClient.on('error', (error) => {
             (0, sentry_1.captureException)(error);
             console.error(`[${this.tmuxSession}] WebSocket error:`, error.message);
@@ -294,6 +304,78 @@ class TmuxSessionHandler {
         };
         return types[ext] || 'application/octet-stream';
     }
+    handleCreateWorktree(branch) {
+        try {
+            const cwd = tmux.getPaneCwd(this.tmuxSession);
+            if (!cwd) {
+                console.error(`[${this.tmuxSession}] Cannot create worktree: no cwd`);
+                return;
+            }
+            // Check if it's a git repo
+            try {
+                (0, child_process_1.execSync)('git rev-parse --is-inside-work-tree', { cwd, stdio: 'pipe', timeout: 5000 });
+            }
+            catch {
+                console.error(`[${this.tmuxSession}] Cannot create worktree: not a git repo`);
+                return;
+            }
+            // Sanitize branch name
+            const safeBranch = branch.replace(/[^a-zA-Z0-9_\-/.]/g, '-');
+            const worktreeDir = path.join(cwd, '.worktrees', safeBranch.replace(/\//g, '-'));
+            console.log(`[${this.tmuxSession}] Creating worktree: branch=${safeBranch}, dir=${worktreeDir}`);
+            // git worktree add
+            (0, child_process_1.execSync)(`git worktree add -b "${safeBranch}" "${worktreeDir}"`, {
+                cwd, stdio: 'pipe', timeout: 10000
+            });
+            // Create new tmux session at worktree path
+            const sessionName = safeBranch.replace(/\//g, '-');
+            if (this.onCreateSession) {
+                this.onCreateSession(sessionName, worktreeDir);
+            }
+            console.log(`[${this.tmuxSession}] Worktree created: ${worktreeDir}`);
+            (0, debug_1.debugLog)(this.tmuxSession, 'Worktree created', { branch: safeBranch, dir: worktreeDir, session: sessionName });
+        }
+        catch (error) {
+            console.error(`[${this.tmuxSession}] Worktree creation failed:`, error.message);
+        }
+    }
+    startMetaTracking() {
+        this.checkAndSendMeta();
+        this.metaCheckTimer = setInterval(() => this.checkAndSendMeta(), META_CHECK_INTERVAL_MS);
+    }
+    stopMetaTracking() {
+        if (this.metaCheckTimer) {
+            clearInterval(this.metaCheckTimer);
+            this.metaCheckTimer = null;
+        }
+    }
+    checkAndSendMeta() {
+        try {
+            const cwd = tmux.getPaneCwd(this.tmuxSession);
+            if (!cwd)
+                return;
+            const gitInfo = tmux.getGitInfo(cwd);
+            const meta = { cwd };
+            if (gitInfo?.branch)
+                meta.gitBranch = gitInfo.branch;
+            if (gitInfo?.remote)
+                meta.gitRemote = gitInfo.remote;
+            if (gitInfo?.repo)
+                meta.gitRepo = gitInfo.repo;
+            const json = JSON.stringify(meta);
+            (0, debug_1.debugLog)(this.tmuxSession, 'Meta check:', { cwd, gitInfo });
+            const changed = json !== this.currentMetaJson;
+            (0, debug_1.debugLog)(this.tmuxSession, changed ? 'Meta CHANGED, sending' : 'Meta unchanged, skip');
+            if (changed) {
+                this.currentMetaJson = json;
+                this.wsClient?.sendSessionMeta(meta);
+                console.log(`[${this.tmuxSession}] Session meta updated: ${json}`);
+            }
+        }
+        catch (error) {
+            // Silently ignore meta check errors
+        }
+    }
     handleKeys(keys, paneId) {
         const target = paneId || this.tmuxSession;
         tmux.sendKeys(target, keys, false);
@@ -405,6 +487,7 @@ class TmuxSessionHandler {
         console.log(`[${this.tmuxSession}] Stopping`);
         this.running = false;
         this.stopScreenCapture();
+        this.stopMetaTracking();
         if (this.wsClient) {
             this.wsClient.destroy();
             this.wsClient = null;

package/dist/agent/tmux.d.ts

@@ -56,4 +56,17 @@ export declare function listPanes(sessionName: string): PaneData[] | null;
  * Capture a specific pane by its pane ID (e.g., %0, %1)
  */
 export declare function capturePaneById(sessionName: string, paneId: string): string | null;
+/**
+ * Git info for a directory
+ */
+export interface GitInfo {
+    branch: string | null;
+    remote: string | null;
+    repo: string | null;
+}
+/**
+ * Detect git info (branch, remote, repo) for a given directory.
+ * Returns null if the directory is not inside a git work tree.
+ */
+export declare function getGitInfo(cwd: string): GitInfo | null;
 export type { PaneData } from './tmux-executor';

package/dist/agent/tmux.js

@@ -14,7 +14,10 @@ exports.getActivePane = getActivePane;
 exports.getPaneCwd = getPaneCwd;
 exports.listPanes = listPanes;
 exports.capturePaneById = capturePaneById;
+exports.getGitInfo = getGitInfo;
 const tmux_executor_1 = require("./tmux-executor");
+const child_process_1 = require("child_process");
+const debug_1 = require("./debug");
 // Lazy-initialized executor (created on first use)
 let executor = null;
 /**
@@ -171,3 +174,30 @@ function listPanes(sessionName) {
 function capturePaneById(sessionName, paneId) {
     return getExecutor().capturePaneById(sessionName, paneId);
 }
+/**
+ * Detect git info (branch, remote, repo) for a given directory.
+ * Returns null if the directory is not inside a git work tree.
+ */
+function getGitInfo(cwd) {
+    try {
+        (0, child_process_1.execSync)('git rev-parse --is-inside-work-tree', { cwd, stdio: 'pipe', timeout: 3000 });
+    }
+    catch {
+        return null;
+    }
+    const run = (cmd) => {
+        try {
+            return (0, child_process_1.execSync)(cmd, { cwd, encoding: 'utf-8', stdio: 'pipe', timeout: 3000 }).trim();
+        }
+        catch {
+            return null;
+        }
+    };
+    const branch = run('git rev-parse --abbrev-ref HEAD');
+    const remote = run('git config --get remote.origin.url');
+    const repo = remote
+        ? remote.replace(/.*github\.com[:/]/, '').replace(/\.git$/, '')
+        : null;
+    (0, debug_1.debugLog)('git', `cwd=${cwd}, branch=${branch}, remote=${remote}, repo=${repo}`);
+    return { branch, remote, repo };
+}

package/dist/agent/types.d.ts

@@ -9,6 +9,21 @@ export interface ApiConfig {
     agentId?: string;
     exec?: ExecConfig;
     llm?: LlmConfig;
+    capabilities?: CapabilitiesConfig;
+}
+/**
+ * Per-capability consent config for the CLI agent.
+ * Each capability can be:
+ *   true   — auto-grant when SDK requests it
+ *   false  — auto-deny
+ *   'ask'  — deny with a log notice (future: interactive prompt)
+ */
+export interface CapabilitiesConfig {
+    exec?: boolean | 'ask';
+    exec_cwd?: boolean | 'ask';
+    llm_chat?: boolean | 'ask';
+    send_keys?: boolean | 'ask';
+    list_sessions?: boolean | 'ask';
 }
 export interface ExecConfig {
     enabled: boolean;
@@ -37,6 +52,12 @@ export interface TmuxSession {
     created?: string;
     attached: boolean;
 }
+export interface SessionMetadata {
+    cwd: string | null;
+    gitBranch: string | null;
+    gitRemote: string | null;
+    gitRepo: string | null;
+}
 export interface ExecResult {
     exitCode: number;
     stdout: string;

package/dist/agent/websocket.d.ts

@@ -33,6 +33,7 @@ export declare class RelayWebSocketClient extends EventEmitter {
     sendScreenWithMeta(data: Buffer, meta: Record<string, string>): boolean;
     sendScreenCompressed(data: Buffer): boolean;
     sendScreenCompressedWithMeta(data: Buffer, meta: Record<string, string>): boolean;
+    sendSessionMeta(meta: Record<string, string>): boolean;
     sendPaneLayout(panes: Array<{
         id: string;
         index: number;

package/dist/agent/websocket.js

@@ -40,6 +40,7 @@ exports.RelayWebSocketClient = void 0;
 const ws_1 = __importDefault(require("ws"));
 const events_1 = require("events");
 const zlib = __importStar(require("zlib"));
+const debug_1 = require("./debug");
 const MAX_RECONNECT_ATTEMPTS = 5;
 const BASE_RECONNECT_DELAY_MS = 2000;
 const MAX_RECONNECT_DELAY_MS = 60000;
@@ -116,6 +117,7 @@ class RelayWebSocketClient extends events_1.EventEmitter {
         });
     }
     handleMessage(message) {
+        (0, debug_1.debugLog)('WS:IN', message.type, message.session);
         switch (message.type) {
             case 'keys':
                 if (message.session === this.sessionId && message.payload) {
@@ -141,6 +143,11 @@ class RelayWebSocketClient extends events_1.EventEmitter {
                     this.emit('killSession');
                 }
                 break;
+            case 'createWorktree':
+                if (message.session === this.sessionId && message.meta?.branch) {
+                    this.emit('createWorktree', message.meta.branch);
+                }
+                break;
             case 'requestFileView':
                 if (message.session === this.sessionId && message.meta?.filePath) {
                     this.emit('requestFileView', message.meta.filePath);
@@ -232,6 +239,8 @@ class RelayWebSocketClient extends events_1.EventEmitter {
             return false;
         }
         try {
+            (0, debug_1.debugLog)('WS:OUT', message.type, message.session, message.type === 'sessionMeta' ? JSON.stringify(message.meta) :
+                message.payload ? `payload=${message.payload.length}bytes` : '');
             this.ws.send(JSON.stringify(message));
             return true;
         }
@@ -291,6 +300,15 @@ class RelayWebSocketClient extends events_1.EventEmitter {
             return this.sendScreenWithMeta(data, meta);
         }
     }
+    sendSessionMeta(meta) {
+        if (!this.isConnected)
+            return false;
+        return this.send({
+            type: 'sessionMeta',
+            session: this.sessionId,
+            meta
+        });
+    }
     sendPaneLayout(panes) {
         if (!this.isConnected)
             return false;

package/dist/commands/agent.d.ts

@@ -1,5 +1,6 @@
 interface AgentOptions {
     config?: string;
+    debug?: boolean;
 }
 export declare function startAgent(options: AgentOptions): Promise<void>;
 export {};

package/dist/commands/agent.js

@@ -7,8 +7,13 @@ exports.startAgent = startAgent;
 const chalk_1 = __importDefault(require("chalk"));
 const runner_1 = require("../agent/runner");
 const sentry_1 = require("../sentry");
+const debug_1 = require("../agent/debug");
 async function startAgent(options) {
     try {
+        if (options.debug) {
+            (0, debug_1.setDebug)(true);
+            console.log(chalk_1.default.yellow('[DEBUG] Debug mode enabled'));
+        }
         const config = runner_1.AgentRunner.loadConfig(options.config);
         const runner = new runner_1.AgentRunner(config);
         await runner.start();

package/dist/index.js

@@ -209,6 +209,7 @@ program
     .command('agent')
     .description('Start the SessionCast agent')
     .option('-c, --config <path>', 'Path to config file')
+    .option('-d, --debug', 'Enable debug logging')
     .action(agent_1.startAgent);
 // Help examples
 program.on('--help', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sessioncast-cli",
-  "version": "2.0.9",
+  "version": "2.2.0",
   "description": "SessionCast CLI - Control your agents from anywhere",
   "main": "dist/index.js",
   "bin": {