sessioncast-cli 2.0.9 → 2.1.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/session-handler.d.ts

@@ -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,9 @@ export declare class TmuxSessionHandler {
      * Get content type from file extension
      */
     private getContentType;
+    private startMetaTracking;
+    private stopMetaTracking;
+    private checkAndSendMeta;
     private handleKeys;
     private startScreenCapture;
     private stopScreenCapture;

package/dist/agent/session-handler.js

@@ -39,6 +39,7 @@ const tmux = __importStar(require("./tmux"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 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 +47,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 +59,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 +93,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}`);
@@ -294,6 +300,43 @@ class TmuxSessionHandler {
         };
         return types[ext] || 'application/octet-stream';
     }
+    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 +448,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) {
@@ -232,6 +234,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 +295,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.1.0",
   "description": "SessionCast CLI - Control your agents from anywhere",
   "main": "dist/index.js",
   "bin": {