@orchagent/cli 0.1.0

package/dist/lib/bundle.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Code bundling utilities for hosted code agents.
+ *
+ * Creates zip bundles from project directories for upload to OrchAgent.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCodeBundle = createCodeBundle;
+exports.detectEntrypoint = detectEntrypoint;
+exports.validateBundle = validateBundle;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const archiver_1 = __importDefault(require("archiver"));
+const fs_1 = require("fs");
+/** Default patterns to exclude from bundles */
+const DEFAULT_EXCLUDES = [
+    // Python
+    '**/__pycache__/**',
+    '**/*.pyc',
+    '**/*.pyo',
+    '**/*.pyd',
+    '.Python',
+    'venv/**',
+    '.venv/**',
+    'env/**',
+    '.env',
+    '**/*.egg-info/**',
+    'dist/**',
+    'build/**',
+    '.eggs/**',
+    '.mypy_cache/**',
+    '.pytest_cache/**',
+    '.ruff_cache/**',
+    'pyproject.toml',
+    'setup.py',
+    'setup.cfg',
+    // Node.js
+    'node_modules/**',
+    'npm-debug.log',
+    'yarn-error.log',
+    'package.json',
+    'package-lock.json',
+    'yarn.lock',
+    'bun.lockb',
+    'tsconfig.json',
+    // Git
+    '.git/**',
+    '.gitignore',
+    '.gitattributes',
+    // IDE
+    '.idea/**',
+    '.vscode/**',
+    '*.swp',
+    '*.swo',
+    '.DS_Store',
+    // Documentation
+    'README.md',
+    'README.rst',
+    'README.txt',
+    'CHANGELOG.md',
+    'LICENSE',
+    'LICENSE.md',
+    'LICENSE.txt',
+    'docs/**',
+    // Docker
+    'Dockerfile',
+    'docker-compose.yml',
+    'docker-compose.yaml',
+    '.dockerignore',
+    // CI/CD
+    '.github/**',
+    '.gitlab-ci.yml',
+    '.travis.yml',
+    '.circleci/**',
+    // Test files
+    'tests/**',
+    'test/**',
+    '*_test.py',
+    'test_*.py',
+    '*.test.js',
+    '*.test.ts',
+    '*.spec.js',
+    '*.spec.ts',
+    '__tests__/**',
+    'conftest.py',
+    'pytest.ini',
+    '.coveragerc',
+    'coverage/**',
+    // OrchAgent
+    'orchagent.json',
+    'bundle.zip',
+    '*.zip',
+    // Scripts and misc
+    'scripts/**',
+    'Makefile',
+    '.editorconfig',
+    '.pre-commit-config.yaml',
+];
+/**
+ * Create a code bundle from a project directory.
+ *
+ * @param sourceDir - The directory to bundle
+ * @param outputPath - Path for the output zip file
+ * @param options - Bundle options
+ * @returns Promise that resolves with bundle metadata
+ */
+async function createCodeBundle(sourceDir, outputPath, options = {}) {
+    const excludePatterns = [...DEFAULT_EXCLUDES, ...(options.exclude || [])];
+    // Verify source directory exists
+    const stat = await promises_1.default.stat(sourceDir);
+    if (!stat.isDirectory()) {
+        throw new Error(`Source path is not a directory: ${sourceDir}`);
+    }
+    // Verify entrypoint exists if specified
+    const entrypoint = options.entrypoint || 'main.py';
+    const entrypointPath = path_1.default.join(sourceDir, entrypoint);
+    try {
+        await promises_1.default.access(entrypointPath);
+    }
+    catch {
+        throw new Error(`Entrypoint file not found: ${entrypoint}`);
+    }
+    // Create output directory if needed
+    const outputDir = path_1.default.dirname(outputPath);
+    await promises_1.default.mkdir(outputDir, { recursive: true });
+    return new Promise((resolve, reject) => {
+        const output = (0, fs_1.createWriteStream)(outputPath);
+        const archive = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
+        let fileCount = 0;
+        output.on('close', () => {
+            resolve({
+                path: outputPath,
+                sizeBytes: archive.pointer(),
+                fileCount,
+            });
+        });
+        archive.on('error', (err) => {
+            reject(err);
+        });
+        archive.on('entry', () => {
+            fileCount++;
+        });
+        archive.pipe(output);
+        // Add directory contents with exclusions
+        archive.glob('**/*', {
+            cwd: sourceDir,
+            ignore: excludePatterns,
+            dot: false,
+        });
+        archive.finalize();
+    });
+}
+/**
+ * Detect the project type and suggest an entrypoint.
+ *
+ * @param projectDir - The project directory to analyze
+ * @returns Detected entrypoint or null if not found
+ */
+async function detectEntrypoint(projectDir) {
+    // Check common Python entrypoints
+    const pythonEntrypoints = ['main.py', 'app.py', 'agent.py', 'run.py', '__main__.py'];
+    for (const entry of pythonEntrypoints) {
+        try {
+            await promises_1.default.access(path_1.default.join(projectDir, entry));
+            return entry;
+        }
+        catch {
+            // Continue checking
+        }
+    }
+    // Check common JS/TS entrypoints
+    const jsEntrypoints = ['main.js', 'index.js', 'agent.js', 'main.ts', 'index.ts', 'agent.ts'];
+    for (const entry of jsEntrypoints) {
+        try {
+            await promises_1.default.access(path_1.default.join(projectDir, entry));
+            return entry;
+        }
+        catch {
+            // Continue checking
+        }
+    }
+    return null;
+}
+/**
+ * Validate a bundle before upload.
+ *
+ * @param bundlePath - Path to the zip file
+ * @param maxSizeBytes - Maximum allowed size
+ * @returns Validation result
+ */
+async function validateBundle(bundlePath, maxSizeBytes = 50 * 1024 * 1024) {
+    try {
+        const stat = await promises_1.default.stat(bundlePath);
+        if (stat.size > maxSizeBytes) {
+            return {
+                valid: false,
+                error: `Bundle exceeds maximum size of ${maxSizeBytes / (1024 * 1024)}MB`,
+                sizeBytes: stat.size,
+            };
+        }
+        return { valid: true, sizeBytes: stat.size };
+    }
+    catch (err) {
+        return {
+            valid: false,
+            error: `Failed to read bundle: ${err}`,
+            sizeBytes: 0,
+        };
+    }
+}

package/dist/lib/config.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.getResolvedConfig = getResolvedConfig;
+exports.getConfigPath = getConfigPath;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.orchagent');
+const CONFIG_PATH = path_1.default.join(CONFIG_DIR, 'config.json');
+const DEFAULT_API_URL = 'https://api.orchagent.io';
+async function loadConfig() {
+    try {
+        const raw = await promises_1.default.readFile(CONFIG_PATH, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return {};
+        }
+        throw err;
+    }
+}
+async function saveConfig(config) {
+    await promises_1.default.mkdir(CONFIG_DIR, { recursive: true });
+    const payload = `${JSON.stringify(config, null, 2)}\n`;
+    await promises_1.default.writeFile(CONFIG_PATH, payload, { mode: 0o600 });
+    await promises_1.default.chmod(CONFIG_PATH, 0o600);
+}
+async function getResolvedConfig(overrides = {}) {
+    const fileConfig = await loadConfig();
+    const apiKey = overrides.api_key ??
+        process.env.ORCHAGENT_API_KEY ??
+        fileConfig.api_key;
+    const apiUrl = overrides.api_url ??
+        process.env.ORCHAGENT_API_URL ??
+        fileConfig.api_url ??
+        DEFAULT_API_URL;
+    const defaultOrg = overrides.default_org ??
+        process.env.ORCHAGENT_DEFAULT_ORG ??
+        fileConfig.default_org;
+    return {
+        apiKey,
+        apiUrl,
+        defaultOrg,
+    };
+}
+function getConfigPath() {
+    return CONFIG_PATH;
+}

package/dist/lib/config.test.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Tests for config loading and saving.
+ *
+ * These tests cover the security-critical config management:
+ * - Loading config from file
+ * - Saving config with proper permissions
+ * - Config resolution priority (overrides > env > file)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+// Mock fs/promises
+vitest_1.vi.mock('fs/promises', () => ({
+    default: {
+        readFile: vitest_1.vi.fn(),
+        writeFile: vitest_1.vi.fn(),
+        mkdir: vitest_1.vi.fn(),
+        chmod: vitest_1.vi.fn(),
+    },
+}));
+const promises_1 = __importDefault(require("fs/promises"));
+const config_1 = require("./config");
+(0, vitest_1.describe)('loadConfig', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.it)('returns empty object when config file missing', async () => {
+        const error = new Error('ENOENT');
+        error.code = 'ENOENT';
+        vitest_1.vi.mocked(promises_1.default.readFile).mockRejectedValueOnce(error);
+        const config = await (0, config_1.loadConfig)();
+        (0, vitest_1.expect)(config).toEqual({});
+    });
+    (0, vitest_1.it)('parses JSON config file', async () => {
+        const configData = {
+            api_key: 'sk_test_123',
+            api_url: 'https://custom.api.com',
+            default_org: 'my-org',
+        };
+        vitest_1.vi.mocked(promises_1.default.readFile).mockResolvedValueOnce(JSON.stringify(configData));
+        const config = await (0, config_1.loadConfig)();
+        (0, vitest_1.expect)(config).toEqual(configData);
+    });
+    (0, vitest_1.it)('throws on non-ENOENT errors', async () => {
+        const error = new Error('Permission denied');
+        error.code = 'EACCES';
+        vitest_1.vi.mocked(promises_1.default.readFile).mockRejectedValueOnce(error);
+        await (0, vitest_1.expect)((0, config_1.loadConfig)()).rejects.toThrow('Permission denied');
+    });
+    (0, vitest_1.it)('reads from ~/.orchagent/config.json', async () => {
+        vitest_1.vi.mocked(promises_1.default.readFile).mockResolvedValueOnce('{}');
+        await (0, config_1.loadConfig)();
+        (0, vitest_1.expect)(promises_1.default.readFile).toHaveBeenCalledWith(path_1.default.join(os_1.default.homedir(), '.orchagent', 'config.json'), 'utf-8');
+    });
+});
+(0, vitest_1.describe)('saveConfig', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+        vitest_1.vi.mocked(promises_1.default.mkdir).mockResolvedValue(undefined);
+        vitest_1.vi.mocked(promises_1.default.writeFile).mockResolvedValue(undefined);
+        vitest_1.vi.mocked(promises_1.default.chmod).mockResolvedValue(undefined);
+    });
+    (0, vitest_1.it)('creates config directory if missing', async () => {
+        await (0, config_1.saveConfig)({ api_key: 'sk_test' });
+        (0, vitest_1.expect)(promises_1.default.mkdir).toHaveBeenCalledWith(path_1.default.join(os_1.default.homedir(), '.orchagent'), { recursive: true });
+    });
+    (0, vitest_1.it)('writes JSON with pretty formatting', async () => {
+        const config = { api_key: 'sk_test_123' };
+        await (0, config_1.saveConfig)(config);
+        (0, vitest_1.expect)(promises_1.default.writeFile).toHaveBeenCalledWith(path_1.default.join(os_1.default.homedir(), '.orchagent', 'config.json'), vitest_1.expect.stringContaining('"api_key": "sk_test_123"'), { mode: 0o600 });
+    });
+    (0, vitest_1.it)('sets restrictive file permissions (0600)', async () => {
+        await (0, config_1.saveConfig)({ api_key: 'sk_test' });
+        // First via writeFile options
+        (0, vitest_1.expect)(promises_1.default.writeFile).toHaveBeenCalledWith(vitest_1.expect.any(String), vitest_1.expect.any(String), { mode: 0o600 });
+        // Then explicitly with chmod
+        (0, vitest_1.expect)(promises_1.default.chmod).toHaveBeenCalledWith(path_1.default.join(os_1.default.homedir(), '.orchagent', 'config.json'), 0o600);
+    });
+    (0, vitest_1.it)('adds trailing newline to file', async () => {
+        await (0, config_1.saveConfig)({ api_key: 'test' });
+        const writeCall = vitest_1.vi.mocked(promises_1.default.writeFile).mock.calls[0];
+        const content = writeCall[1];
+        (0, vitest_1.expect)(content.endsWith('\n')).toBe(true);
+    });
+});
+(0, vitest_1.describe)('getResolvedConfig', () => {
+    const originalEnv = process.env;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+        process.env = { ...originalEnv };
+        // Default: no config file
+        const error = new Error('ENOENT');
+        error.code = 'ENOENT';
+        vitest_1.vi.mocked(promises_1.default.readFile).mockRejectedValue(error);
+    });
+    (0, vitest_1.afterEach)(() => {
+        process.env = originalEnv;
+    });
+    (0, vitest_1.it)('uses default API URL when not configured', async () => {
+        const config = await (0, config_1.getResolvedConfig)();
+        (0, vitest_1.expect)(config.apiUrl).toBe('https://api.orchagent.com');
+    });
+    (0, vitest_1.it)('reads API key from file config', async () => {
+        vitest_1.vi.mocked(promises_1.default.readFile).mockResolvedValueOnce(JSON.stringify({ api_key: 'sk_from_file' }));
+        const config = await (0, config_1.getResolvedConfig)();
+        (0, vitest_1.expect)(config.apiKey).toBe('sk_from_file');
+    });
+    (0, vitest_1.it)('prioritizes env vars over file config', async () => {
+        process.env.ORCHAGENT_API_KEY = 'sk_from_env';
+        vitest_1.vi.mocked(promises_1.default.readFile).mockResolvedValueOnce(JSON.stringify({ api_key: 'sk_from_file' }));
+        const config = await (0, config_1.getResolvedConfig)();
+        (0, vitest_1.expect)(config.apiKey).toBe('sk_from_env');
+    });
+    (0, vitest_1.it)('prioritizes overrides over env vars', async () => {
+        process.env.ORCHAGENT_API_KEY = 'sk_from_env';
+        const config = await (0, config_1.getResolvedConfig)({ api_key: 'sk_override' });
+        (0, vitest_1.expect)(config.apiKey).toBe('sk_override');
+    });
+    (0, vitest_1.it)('resolves API URL from env var', async () => {
+        process.env.ORCHAGENT_API_URL = 'https://custom.api.com';
+        const config = await (0, config_1.getResolvedConfig)();
+        (0, vitest_1.expect)(config.apiUrl).toBe('https://custom.api.com');
+    });
+    (0, vitest_1.it)('resolves default org from env var', async () => {
+        process.env.ORCHAGENT_DEFAULT_ORG = 'my-org';
+        const config = await (0, config_1.getResolvedConfig)();
+        (0, vitest_1.expect)(config.defaultOrg).toBe('my-org');
+    });
+    (0, vitest_1.it)('returns undefined apiKey when not set anywhere', async () => {
+        const config = await (0, config_1.getResolvedConfig)();
+        (0, vitest_1.expect)(config.apiKey).toBeUndefined();
+    });
+});
+(0, vitest_1.describe)('getConfigPath', () => {
+    (0, vitest_1.it)('returns path to config file', () => {
+        const configPath = (0, config_1.getConfigPath)();
+        (0, vitest_1.expect)(configPath).toBe(path_1.default.join(os_1.default.homedir(), '.orchagent', 'config.json'));
+    });
+});

package/dist/lib/errors.js

@@ -0,0 +1,75 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliError = void 0;
+exports.formatError = formatError;
+exports.exitWithError = exitWithError;
+const Sentry = __importStar(require("@sentry/node"));
+const analytics_1 = require("./analytics");
+class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.exitCode = exitCode;
+    }
+}
+exports.CliError = CliError;
+function formatError(err) {
+    if (err instanceof CliError) {
+        return err.message;
+    }
+    if (err instanceof Error) {
+        const anyErr = err;
+        if (anyErr.status && anyErr.payload) {
+            return `${anyErr.message} (status ${anyErr.status})`;
+        }
+        return anyErr.message;
+    }
+    return String(err);
+}
+async function exitWithError(err) {
+    const message = formatError(err);
+    // Report to Sentry if it's a real error (not a CliError which is expected)
+    if (!(err instanceof CliError) && process.env.SENTRY_DSN) {
+        Sentry.captureException(err);
+    }
+    // Flush PostHog before exiting
+    await (0, analytics_1.shutdownPostHog)();
+    process.stderr.write(`${message}\n`);
+    if (err instanceof CliError) {
+        process.exit(err.exitCode);
+    }
+    process.exit(1);
+}