sessioncast-cli 1.0.0

package/dist/commands/agent.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startAgent = startAgent;
+const chalk_1 = __importDefault(require("chalk"));
+const runner_1 = require("../agent/runner");
+async function startAgent(options) {
+    try {
+        const config = runner_1.AgentRunner.loadConfig(options.config);
+        const runner = new runner_1.AgentRunner(config);
+        await runner.start();
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+}

package/dist/commands/agents.d.ts

@@ -0,0 +1 @@
+export declare function listAgents(): Promise<void>;

package/dist/commands/agents.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAgents = listAgents;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const api_1 = require("../api");
+const config_1 = require("../config");
+async function listAgents() {
+    if (!(0, config_1.isLoggedIn)()) {
+        console.log(chalk_1.default.red('Not logged in. Run: sessioncast login <api-key>'));
+        process.exit(1);
+    }
+    const spinner = (0, ora_1.default)('Fetching agents...').start();
+    try {
+        const agents = await api_1.api.listAgents();
+        spinner.stop();
+        if (agents.length === 0) {
+            console.log(chalk_1.default.yellow('No agents found.'));
+            console.log(chalk_1.default.gray('Create an agent at https://account.sessioncast.io'));
+            return;
+        }
+        console.log(chalk_1.default.bold('\nYour Agents:\n'));
+        // Table header
+        console.log(chalk_1.default.gray(padRight('NAME', 20) +
+            padRight('STATUS', 12) +
+            padRight('API', 8) +
+            padRight('LAST SEEN', 20) +
+            'ID'));
+        console.log(chalk_1.default.gray('─'.repeat(80)));
+        // Table rows
+        for (const agent of agents) {
+            const name = agent.label || agent.machineId || 'unnamed';
+            const status = agent.isActive ? chalk_1.default.green('● online') : chalk_1.default.gray('○ offline');
+            const apiStatus = agent.apiEnabled ? chalk_1.default.green('yes') : chalk_1.default.gray('no');
+            const lastSeen = agent.lastConnectedAt
+                ? formatRelativeTime(new Date(agent.lastConnectedAt))
+                : chalk_1.default.gray('never');
+            console.log(padRight(name, 20) +
+                padRight(status, 12) +
+                padRight(apiStatus, 8) +
+                padRight(lastSeen, 20) +
+                chalk_1.default.gray(agent.id.substring(0, 8)));
+        }
+        console.log();
+    }
+    catch (error) {
+        spinner.stop();
+        console.log(chalk_1.default.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+}
+function padRight(str, len) {
+    // Remove ANSI codes for length calculation
+    const plainStr = str.replace(/\x1b\[[0-9;]*m/g, '');
+    const padding = Math.max(0, len - plainStr.length);
+    return str + ' '.repeat(padding);
+}
+function formatRelativeTime(date) {
+    const now = new Date();
+    const diff = now.getTime() - date.getTime();
+    const seconds = Math.floor(diff / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (seconds < 60)
+        return 'just now';
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    if (hours < 24)
+        return `${hours}h ago`;
+    if (days < 7)
+        return `${days}d ago`;
+    return date.toLocaleDateString();
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,5 @@
+export declare function login(apiKey: string, options: {
+    url?: string;
+}): Promise<void>;
+export declare function logout(): Promise<void>;
+export declare function status(): void;

package/dist/commands/login.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.login = login;
+exports.logout = logout;
+exports.status = status;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../config");
+async function login(apiKey, options) {
+    if (options.url) {
+        (0, config_1.setApiUrl)(options.url);
+        console.log(chalk_1.default.gray(`API URL set to: ${options.url}`));
+    }
+    // Validate API key format
+    if (!apiKey.startsWith('sk-')) {
+        console.log(chalk_1.default.red('Invalid API key format. Key should start with "sk-"'));
+        process.exit(1);
+    }
+    (0, config_1.setApiKey)(apiKey);
+    console.log(chalk_1.default.green('✓ Logged in successfully!'));
+    console.log(chalk_1.default.gray('Your API key has been saved.'));
+}
+async function logout() {
+    if (!(0, config_1.isLoggedIn)()) {
+        console.log(chalk_1.default.yellow('Not logged in.'));
+        return;
+    }
+    (0, config_1.clearApiKey)();
+    console.log(chalk_1.default.green('✓ Logged out successfully!'));
+}
+function status() {
+    if ((0, config_1.isLoggedIn)()) {
+        console.log(chalk_1.default.green('✓ Logged in'));
+    }
+    else {
+        console.log(chalk_1.default.yellow('Not logged in'));
+        console.log(chalk_1.default.gray('Run: sessioncast login <api-key>'));
+    }
+}

package/dist/commands/project.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Initialize a new project
+ */
+export declare function projectInit(projectPath: string, options: {
+    name?: string;
+}): Promise<void>;
+/**
+ * Run workflow
+ */
+export declare function projectRun(projectPath: string, options: {
+    watch?: boolean;
+    noClaude?: boolean;
+    relayUrl?: string;
+    relayToken?: string;
+}): Promise<void>;
+/**
+ * Show project status
+ */
+export declare function projectStatus(projectPath: string): Promise<void>;
+/**
+ * Stop workflow and kill sessions
+ */
+export declare function projectStop(projectPath: string): Promise<void>;
+/**
+ * List agents and send commands
+ */
+export declare function projectSend(projectPath: string, agentId: string, message: string): Promise<void>;
+/**
+ * Create a sample workflow
+ */
+export declare function projectCreateWorkflow(projectPath: string, options: {
+    template?: string;
+}): Promise<void>;

package/dist/commands/project.js

@@ -0,0 +1,359 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectInit = projectInit;
+exports.projectRun = projectRun;
+exports.projectStatus = projectStatus;
+exports.projectStop = projectStop;
+exports.projectSend = projectSend;
+exports.projectCreateWorkflow = projectCreateWorkflow;
+const chalk_1 = __importDefault(require("chalk"));
+const path = __importStar(require("path"));
+const project_1 = require("../project");
+/**
+ * Initialize a new project
+ */
+async function projectInit(projectPath, options) {
+    const resolvedPath = path.resolve(projectPath || '.');
+    console.log(chalk_1.default.blue('Initializing SessionCast project...'));
+    console.log(chalk_1.default.gray(`Path: ${resolvedPath}`));
+    const manager = new project_1.ProjectManager(resolvedPath);
+    const project = manager.init(options.name);
+    console.log(chalk_1.default.green('\nProject initialized successfully!'));
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    console.log(`  Name: ${chalk_1.default.bold(project.name)}`);
+    console.log(`  Path: ${project.path}`);
+    console.log(`  Status: ${project.status}`);
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    console.log(chalk_1.default.yellow('\nFolder structure created:'));
+    console.log('  mission/       - Mission history and refined mission');
+    console.log('  flow/          - Workflow definitions');
+    console.log('  shared/        - Shared context between agents');
+    console.log('  tools/         - Meta tools (mission-refiner, pm-agent)');
+    console.log('  work/          - Work agents');
+    console.log(chalk_1.default.cyan('\nNext steps:'));
+    console.log('  1. Define your workflow in flow/workflow.yml');
+    console.log('  2. Or start mission refinement:');
+    console.log(chalk_1.default.gray(`     cd ${resolvedPath}/tools/mission-refiner && claude`));
+    console.log('  3. Run the workflow:');
+    console.log(chalk_1.default.gray(`     sessioncast project run ${resolvedPath}`));
+}
+/**
+ * Run workflow
+ */
+async function projectRun(projectPath, options) {
+    const resolvedPath = path.resolve(projectPath || '.');
+    console.log(chalk_1.default.blue('Running SessionCast workflow...'));
+    console.log(chalk_1.default.gray(`Path: ${resolvedPath}`));
+    const manager = new project_1.ProjectManager(resolvedPath);
+    const project = manager.load();
+    if (!project) {
+        console.error(chalk_1.default.red('Error: Not a SessionCast project. Run `sessioncast project init` first.'));
+        process.exit(1);
+    }
+    const workflow = manager.loadWorkflow();
+    if (!workflow) {
+        console.error(chalk_1.default.red('Error: No workflow.yml found. Define your workflow first.'));
+        process.exit(1);
+    }
+    // Use default dev token for local development
+    let relayToken = options.relayToken;
+    if (options.relayUrl && !relayToken) {
+        const isDevRelay = options.relayUrl.includes('localhost') || options.relayUrl.includes('127.0.0.1');
+        if (isDevRelay) {
+            relayToken = 'dev@localhost';
+            console.log(chalk_1.default.gray('  Using default dev token: dev@localhost'));
+        }
+    }
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    console.log(`  Workflow: ${chalk_1.default.bold(workflow.name)}`);
+    console.log(`  Mission: ${workflow.mission}`);
+    console.log(`  Agents: ${workflow.agents.map(a => a.id).join(', ')}`);
+    console.log(`  Auto-launch Claude: ${options.noClaude ? 'No' : 'Yes'}`);
+    if (options.relayUrl) {
+        console.log(`  Relay: ${options.relayUrl}`);
+    }
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    const executor = new project_1.WorkflowExecutor(manager, {
+        autoLaunchClaude: !options.noClaude,
+        relayUrl: options.relayUrl,
+        relayToken: relayToken
+    });
+    executor.on('agent-started', ({ agentId, sessionName }) => {
+        console.log(chalk_1.default.cyan(`[${agentId}] Started - tmux session: ${sessionName}`));
+    });
+    executor.on('agent-completed', ({ agentId, output }) => {
+        console.log(chalk_1.default.green(`[${agentId}] Completed`));
+        if (output) {
+            console.log(chalk_1.default.gray(`  Output: ${output.substring(0, 100)}...`));
+        }
+    });
+    executor.on('workflow-completed', () => {
+        console.log(chalk_1.default.green.bold('\nWorkflow completed successfully!'));
+        if (!options.watch) {
+            process.exit(0);
+        }
+    });
+    executor.on('workflow-failed', () => {
+        console.log(chalk_1.default.red.bold('\nWorkflow failed!'));
+        const status = manager.loadStatus();
+        if (status) {
+            for (const [agentId, agentStatus] of Object.entries(status.agents)) {
+                if (agentStatus.status === 'failed') {
+                    console.log(chalk_1.default.red(`  [${agentId}] ${agentStatus.error || 'Unknown error'}`));
+                }
+            }
+        }
+        if (!options.watch) {
+            process.exit(1);
+        }
+    });
+    // Handle shutdown
+    process.on('SIGINT', () => {
+        console.log(chalk_1.default.yellow('\nStopping workflow...'));
+        executor.stop();
+        process.exit(0);
+    });
+    await executor.start();
+    if (options.watch) {
+        console.log(chalk_1.default.gray('\nWatching for changes... (Ctrl+C to stop)'));
+    }
+}
+/**
+ * Show project status
+ */
+async function projectStatus(projectPath) {
+    const resolvedPath = path.resolve(projectPath || '.');
+    const manager = new project_1.ProjectManager(resolvedPath);
+    const project = manager.load();
+    if (!project) {
+        console.error(chalk_1.default.red('Error: Not a SessionCast project.'));
+        process.exit(1);
+    }
+    const workflow = manager.loadWorkflow();
+    const status = manager.loadStatus();
+    const executor = new project_1.WorkflowExecutor(manager);
+    const sessions = executor.listSessions();
+    console.log(chalk_1.default.blue('SessionCast Project Status'));
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    console.log(`  Project: ${chalk_1.default.bold(project.name)}`);
+    console.log(`  Path: ${project.path}`);
+    console.log(`  Status: ${colorStatus(project.status)}`);
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    if (workflow) {
+        console.log(chalk_1.default.yellow('\nWorkflow:'));
+        console.log(`  Name: ${workflow.name}`);
+        console.log(`  Mission: ${workflow.mission}`);
+        console.log(`  Agents: ${workflow.agents.length}`);
+        if (status) {
+            console.log(chalk_1.default.yellow('\nAgent Status:'));
+            for (const agent of workflow.agents) {
+                const agentStatus = status.agents[agent.id];
+                const statusStr = agentStatus ? colorStatus(agentStatus.status) : chalk_1.default.gray('not started');
+                const isRunning = sessions.includes(agent.id);
+                const sessionIndicator = isRunning ? chalk_1.default.green(' [tmux]') : '';
+                console.log(`  ${agent.id}: ${statusStr}${sessionIndicator}`);
+                if (agentStatus?.currentTask) {
+                    console.log(chalk_1.default.gray(`    → ${agentStatus.currentTask}`));
+                }
+                if (agentStatus?.error) {
+                    console.log(chalk_1.default.red(`    ! ${agentStatus.error}`));
+                }
+            }
+        }
+    }
+    else {
+        console.log(chalk_1.default.yellow('\nNo workflow defined yet.'));
+        console.log(chalk_1.default.gray('Create flow/workflow.yml to define your workflow.'));
+    }
+    if (sessions.length > 0) {
+        console.log(chalk_1.default.yellow('\nActive Sessions:'));
+        for (const session of sessions) {
+            console.log(`  ${session}`);
+        }
+    }
+}
+/**
+ * Stop workflow and kill sessions
+ */
+async function projectStop(projectPath) {
+    const resolvedPath = path.resolve(projectPath || '.');
+    console.log(chalk_1.default.blue('Stopping SessionCast workflow...'));
+    const manager = new project_1.ProjectManager(resolvedPath);
+    const executor = new project_1.WorkflowExecutor(manager);
+    executor.killAllSessions();
+    console.log(chalk_1.default.green('All sessions stopped.'));
+}
+/**
+ * List agents and send commands
+ */
+async function projectSend(projectPath, agentId, message) {
+    const resolvedPath = path.resolve(projectPath || '.');
+    const manager = new project_1.ProjectManager(resolvedPath);
+    const executor = new project_1.WorkflowExecutor(manager);
+    if (executor.sendToAgent(agentId, message)) {
+        console.log(chalk_1.default.green(`Sent to ${agentId}: ${message}`));
+    }
+    else {
+        console.error(chalk_1.default.red(`Failed to send to ${agentId}. Is the session running?`));
+        process.exit(1);
+    }
+}
+/**
+ * Create a sample workflow
+ */
+async function projectCreateWorkflow(projectPath, options) {
+    const resolvedPath = path.resolve(projectPath || '.');
+    const manager = new project_1.ProjectManager(resolvedPath);
+    const project = manager.load();
+    if (!project) {
+        console.error(chalk_1.default.red('Error: Not a SessionCast project.'));
+        process.exit(1);
+    }
+    const template = options.template || 'basic';
+    const workflow = getWorkflowTemplate(template, project.name);
+    manager.saveWorkflow(workflow);
+    // Create work folders
+    for (const agent of workflow.agents) {
+        manager.createWorkAgent(agent.id, agent.name, agent.tasks);
+    }
+    console.log(chalk_1.default.green(`Created workflow from template: ${template}`));
+    console.log(chalk_1.default.gray(`File: ${resolvedPath}/flow/workflow.yml`));
+    console.log(chalk_1.default.yellow('\nAgents created:'));
+    for (const agent of workflow.agents) {
+        console.log(`  ${agent.id} - ${agent.name}`);
+    }
+}
+function getWorkflowTemplate(template, projectName) {
+    switch (template) {
+        case 'android':
+            return {
+                name: projectName,
+                mission: 'Android app development',
+                created: new Date().toISOString(),
+                agents: [
+                    {
+                        id: 'android',
+                        name: 'Android Development',
+                        workDir: 'work/android',
+                        tasks: ['Feature implementation', 'UI development'],
+                        dependsOn: []
+                    },
+                    {
+                        id: 'qa',
+                        name: 'QA Testing',
+                        workDir: 'work/qa',
+                        tasks: ['Unit tests', 'Integration tests'],
+                        dependsOn: ['android']
+                    },
+                    {
+                        id: 'release',
+                        name: 'Release',
+                        workDir: 'work/release',
+                        tasks: ['Version tagging', 'Release notes'],
+                        dependsOn: ['qa']
+                    }
+                ]
+            };
+        case 'fullstack':
+            return {
+                name: projectName,
+                mission: 'Fullstack development',
+                created: new Date().toISOString(),
+                agents: [
+                    {
+                        id: 'backend',
+                        name: 'Backend Development',
+                        workDir: 'work/backend',
+                        tasks: ['API implementation', 'Database schema'],
+                        dependsOn: []
+                    },
+                    {
+                        id: 'frontend',
+                        name: 'Frontend Development',
+                        workDir: 'work/frontend',
+                        tasks: ['UI components', 'API integration'],
+                        dependsOn: ['backend']
+                    },
+                    {
+                        id: 'qa',
+                        name: 'QA Testing',
+                        workDir: 'work/qa',
+                        tasks: ['E2E tests', 'Performance tests'],
+                        dependsOn: ['frontend']
+                    }
+                ]
+            };
+        default: // basic
+            return {
+                name: projectName,
+                mission: 'Project mission (edit this)',
+                created: new Date().toISOString(),
+                agents: [
+                    {
+                        id: 'dev',
+                        name: 'Development',
+                        workDir: 'work/dev',
+                        tasks: ['Implement features'],
+                        dependsOn: []
+                    },
+                    {
+                        id: 'test',
+                        name: 'Testing',
+                        workDir: 'work/test',
+                        tasks: ['Write tests'],
+                        dependsOn: ['dev']
+                    }
+                ]
+            };
+    }
+}
+function colorStatus(status) {
+    switch (status) {
+        case 'completed':
+            return chalk_1.default.green(status);
+        case 'running':
+            return chalk_1.default.cyan(status);
+        case 'failed':
+            return chalk_1.default.red(status);
+        case 'pending':
+            return chalk_1.default.yellow(status);
+        default:
+            return chalk_1.default.gray(status);
+    }
+}

package/dist/commands/sendkeys.d.ts

@@ -0,0 +1,3 @@
+export declare function sendKeys(target: string, keys: string, options: {
+    noEnter?: boolean;
+}): Promise<void>;

package/dist/commands/sendkeys.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendKeys = sendKeys;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const api_1 = require("../api");
+const config_1 = require("../config");
+async function sendKeys(target, keys, options) {
+    if (!(0, config_1.isLoggedIn)()) {
+        console.log(chalk_1.default.red('Not logged in. Run: sessioncast login <api-key>'));
+        process.exit(1);
+    }
+    // Parse target: "agent:session" or "agent:session:window"
+    const parts = target.split(':');
+    if (parts.length < 2) {
+        console.log(chalk_1.default.red('Invalid target format.'));
+        console.log(chalk_1.default.gray('Expected: <agent>:<session> or <agent>:<session>:<window>'));
+        console.log(chalk_1.default.gray('Example: macbook:dev or server:main:0'));
+        process.exit(1);
+    }
+    const agentName = parts[0];
+    const sessionTarget = parts.slice(1).join(':'); // session:window or just session
+    const spinner = (0, ora_1.default)('Finding agent...').start();
+    try {
+        // Find agent by name/label/machineId
+        const agent = await api_1.api.findAgentByName(agentName);
+        if (!agent) {
+            spinner.stop();
+            console.log(chalk_1.default.red(`Agent not found: ${agentName}`));
+            console.log(chalk_1.default.gray('Run: sessioncast agents'));
+            process.exit(1);
+        }
+        if (!agent.isActive) {
+            spinner.stop();
+            console.log(chalk_1.default.red(`Agent is offline: ${agentName}`));
+            process.exit(1);
+        }
+        if (!agent.apiEnabled) {
+            spinner.stop();
+            console.log(chalk_1.default.red(`API is not enabled for agent: ${agentName}`));
+            console.log(chalk_1.default.gray('Enable API in agent settings at https://account.sessioncast.io'));
+            process.exit(1);
+        }
+        spinner.text = 'Sending keys...';
+        const result = await api_1.api.sendKeys(agent.id, sessionTarget, keys, !options.noEnter);
+        spinner.stop();
+        if (result.success) {
+            console.log(chalk_1.default.green(`✓ Keys sent to ${target}`));
+            if (!options.noEnter) {
+                console.log(chalk_1.default.gray('(Enter key was pressed)'));
+            }
+        }
+        else {
+            console.log(chalk_1.default.red(`Failed to send keys: ${result.error || 'Unknown error'}`));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.stop();
+        console.log(chalk_1.default.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+}

package/dist/commands/sessions.d.ts

@@ -0,0 +1 @@
+export declare function listSessions(agentName?: string): Promise<void>;