@guildai/cli 0.10.0 → 0.12.0

package/dist/lib/agent-helpers.js

@@ -1,306 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import { createHash } from 'crypto';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { loadLocalConfig } from './guild-config.js';
-import { runGit } from './git.js';
-import { resolveOwnerId } from './owner-helpers.js';
-import { pollUntilComplete } from './polling.js';
-// ---------------------------------------------------------------------------
-// Build error types
-// ---------------------------------------------------------------------------
-/** Thrown when the ephemeral version build times out or polling fails. */
-export class BuildTimeoutError extends Error {
-    constructor(message = 'The agent version build timed out or failed to report status.') {
-        super(message);
-        this.name = 'BuildTimeoutError';
-    }
-}
-/** Thrown when the ephemeral version build fails validation. */
-export class BuildFailedError extends Error {
-    failedSteps;
-    constructor(failedSteps) {
-        const stepSummary = failedSteps.length > 0
-            ? failedSteps
-                .map((s) => `Step "${s.name}" failed:${s.content ? `\n${s.content}` : ''}`)
-                .join('\n')
-            : 'No failed steps found. Check validation logs for details.';
-        super(`Build failed\n\n${stepSummary}\n\nFix the issues and retry.`);
-        this.name = 'BuildFailedError';
-        this.failedSteps = failedSteps;
-    }
-}
-const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/**
- * Resolve an agent identifier to a fully-qualified form.
- *
- * If the identifier already contains `~` or is a UUID, return it verbatim.
- * Otherwise, resolve the default owner and prepend `owner.name~`.
- */
-export async function resolveAgentRef(client, identifier) {
-    if (identifier.includes('~') || UUID_RE.test(identifier)) {
-        return identifier;
-    }
-    if (identifier.includes('/')) {
-        return identifier.replace('/', '~');
-    }
-    const owner = await resolveOwnerId({ client, interactive: false });
-    return `${owner.name}~${identifier}`;
-}
-/**
- * Get agent ID from argument or guild.json in current directory
- * @param agentIdArg - Optional agent ID from command argument
- * @param cwd - Current working directory (defaults to process.cwd())
- * @returns Agent ID and config (if from guild.json)
- * @throws Error if neither argument nor guild.json provides an agent ID
- */
-export async function getAgentId(agentIdArg, cwd = process.cwd()) {
-    // If agent ID provided as argument, use it
-    if (agentIdArg) {
-        return { agentId: agentIdArg };
-    }
-    // Try to read from guild.json
-    const config = await loadLocalConfig(cwd);
-    if (!config) {
-        console.error('Error: No agent ID provided and not in an agent directory');
-        console.error('');
-        console.error('Either provide an agent ID:');
-        console.error('  guild agent <command> <agent-id>');
-        console.error('');
-        console.error('Or run from an agent directory with guild.json:');
-        console.error('  cd <agent-directory>');
-        console.error('  guild agent <command>');
-        console.error('');
-        console.error('To initialize an agent directory:');
-        console.error('  guild agent init --name my-agent');
-        console.error('');
-        console.error('Or clone an existing agent:');
-        console.error('  guild agent clone <agent-id>');
-        process.exit(1);
-    }
-    if (!config.agent_id) {
-        console.error('Error: guild.json is missing agent_id field');
-        console.error('');
-        console.error('Your guild.json file appears to be corrupted.');
-        console.error('Expected format:');
-        console.error('  {');
-        console.error('    "agent_id": "...",');
-        console.error('    "name": "..."');
-        console.error('  }');
-        process.exit(1);
-    }
-    return { agentId: config.agent_id, config };
-}
-const REQUIRED_AGENT_FILES = ['agent.ts', 'package.json'];
-/**
- * Read agent files from disk for ephemeral version creation.
- * Uses git ls-files to respect .gitignore.
- * @returns Array of {path, content} objects
- */
-export async function readAgentFiles(cwd) {
-    const { stdout } = await runGit(['ls-files', '--cached', '--others', '--exclude-standard'], { cwd });
-    const gitFiles = stdout.split('\n').filter((f) => f.trim().length > 0);
-    const relevantFiles = gitFiles.filter((f) => !f.startsWith('.guild/'));
-    const files = [];
-    for (const filePath of relevantFiles) {
-        const fullPath = path.join(cwd, filePath);
-        const content = await fs.readFile(fullPath, 'utf-8');
-        files.push({ path: filePath, content });
-    }
-    const filePaths = files.map((f) => f.path);
-    const missing = REQUIRED_AGENT_FILES.filter((req) => !filePaths.some((fp) => fp === req || fp.endsWith(`/${req}`)));
-    if (missing.length > 0) {
-        throw new Error(`Missing required files: ${missing.join(', ')}`);
-    }
-    return files;
-}
-const CACHE_DIR = path.join('.guild', 'cache');
-const CACHE_FILE = 'last-ephemeral.json';
-/**
- * Compute a deterministic hash of agent files.
- * Sorts by path to ensure consistent ordering.
- */
-export function hashAgentFiles(files) {
-    const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
-    const hash = createHash('sha256');
-    for (const file of sorted) {
-        hash.update(file.path);
-        hash.update('\0');
-        hash.update(file.content);
-        hash.update('\0');
-    }
-    return hash.digest('hex');
-}
-async function readEphemeralCache(cwd) {
-    try {
-        const cachePath = path.join(cwd, CACHE_DIR, CACHE_FILE);
-        const raw = await fs.readFile(cachePath, 'utf-8');
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.hash === 'string' && typeof parsed.version_id === 'string') {
-            return { hash: parsed.hash, version_id: parsed.version_id };
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-async function writeEphemeralCache(cwd, cache) {
-    const dir = path.join(cwd, CACHE_DIR);
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(path.join(dir, CACHE_FILE), JSON.stringify(cache, null, 2) + '\n');
-}
-/**
- * Get or create an ephemeral version, skipping the build if files haven't
- * changed since the last successful ephemeral build.
- *
- * Returns the version (cached or newly created), a cache hit flag, and the
- * computed hash (used by buildEphemeralVersion to write the cache on success).
- */
-export async function getOrCreateEphemeral(client, agentId, files, cwd, summary, options) {
-    const hash = hashAgentFiles(files);
-    if (options?.noCache) {
-        const version = (await client.post(`/agents/${agentId}/versions`, {
-            files,
-            summary,
-            version_type: 'EPHEMERAL',
-        }));
-        return { version, cached: false, hash };
-    }
-    const cache = await readEphemeralCache(cwd);
-    if (cache && cache.hash === hash) {
-        // Verify the cached version still exists on the server
-        try {
-            const version = (await client.get(`/versions/${cache.version_id}`));
-            if (version.validation_status === 'PASSED') {
-                return { version, cached: true, hash };
-            }
-        }
-        catch {
-            // Version gone or inaccessible — fall through to create new one
-        }
-    }
-    const version = (await client.post(`/agents/${agentId}/versions`, {
-        files,
-        summary,
-        version_type: 'EPHEMERAL',
-    }));
-    return { version, cached: false, hash };
-}
-/**
- * Build an ephemeral version end-to-end: get-or-create, poll for validation,
- * cache on success, and report build failures.
- *
- * Consolidates the build/poll/cache pattern used by both `guild agent test`
- * and `guild agent chat`.
- */
-export async function buildEphemeralVersion(client, agentId, files, cwd, summary, options) {
-    const { version: initial, cached, hash, } = await getOrCreateEphemeral(client, agentId, files, cwd, summary, options);
-    if (cached) {
-        return { version: initial, cached: true };
-    }
-    // Poll for validation to complete
-    const pollResult = await pollUntilComplete({
-        resourceId: initial.id,
-        endpoint: `/versions/${initial.id}`,
-        isComplete: (r) => r.validation_status !== 'PENDING' && r.validation_status !== 'RUNNING',
-        message: 'Building...',
-        successMessage: 'Build finished',
-        timeoutMessage: 'Build timed out',
-        maxAttempts: 120,
-        delayMs: 1000,
-    });
-    if (!pollResult.success || !pollResult.response) {
-        throw new BuildTimeoutError();
-    }
-    const version = pollResult.response;
-    // Cache the successful build so we can skip it next time
-    if (version.validation_status === 'PASSED') {
-        await writeEphemeralCache(cwd, { hash, version_id: version.id });
-    }
-    if (version.validation_status === 'FAILED') {
-        let failedSteps = [];
-        try {
-            const stepsResponse = await client.get(`/versions/${version.id}/validation/steps`);
-            failedSteps = stepsResponse.steps
-                .filter((step) => step.status === 'FAILED')
-                .map((step) => ({ name: step.name, content: step.content ?? undefined }));
-        }
-        catch {
-            // Could not fetch validation details — throw with empty steps
-        }
-        throw new BuildFailedError(failedSteps);
-    }
-    return { version, cached: false };
-}
-// ---------------------------------------------------------------------------
-// Bundle version
-// ---------------------------------------------------------------------------
-/** Thrown when the specified bundle file cannot be found on disk. */
-export class BundleNotFoundError extends Error {
-    constructor(filePath) {
-        super(`Bundle file not found: ${filePath}`);
-        this.name = 'BundleNotFoundError';
-    }
-}
-/**
- * Upload a pre-built bundle as an ephemeral version.
- *
- * The bundle file must be gzip+base64 encoded (the output of
- * `esbuild ... | gzip | base64`). Source files are included for
- * dashboard viewing, but the server skips its own build step because
- * the ready-to-run artifact is already provided.
- */
-export async function buildBundledVersion(client, agentId, bundlePath, cwd, summary) {
-    try {
-        await fs.access(bundlePath);
-    }
-    catch {
-        throw new BundleNotFoundError(bundlePath);
-    }
-    const bundle = (await fs.readFile(bundlePath, 'utf-8')).trim();
-    let files = [];
-    try {
-        files = await readAgentFiles(cwd);
-    }
-    catch {
-        // No git or missing required files — proceed with bundle-only upload
-    }
-    const initial = (await client.post(`/agents/${agentId}/versions`, {
-        version_type: 'EPHEMERAL',
-        bundle,
-        encoding: 'gzip;base64',
-        files,
-        summary,
-    }));
-    const pollResult = await pollUntilComplete({
-        resourceId: initial.id,
-        endpoint: `/versions/${initial.id}`,
-        isComplete: (r) => r.validation_status !== 'PENDING' && r.validation_status !== 'RUNNING',
-        message: 'Validating bundle...',
-        successMessage: 'Bundle validated',
-        timeoutMessage: 'Bundle validation timed out',
-        maxAttempts: 120,
-        delayMs: 1000,
-    });
-    if (!pollResult.success || !pollResult.response) {
-        throw new BuildTimeoutError('Bundle validation timed out.');
-    }
-    const version = pollResult.response;
-    if (version.validation_status === 'FAILED') {
-        let failedSteps = [];
-        try {
-            const stepsResponse = await client.get(`/versions/${version.id}/validation/steps`);
-            failedSteps = stepsResponse.steps
-                .filter((step) => step.status === 'FAILED')
-                .map((step) => ({ name: step.name, content: step.content ?? undefined }));
-        }
-        catch {
-            // Could not fetch validation details — throw with empty steps
-        }
-        throw new BuildFailedError(failedSteps);
-    }
-    return { version };
-}
-//# sourceMappingURL=agent-helpers.js.map

package/dist/lib/alternate-screen.js

@@ -1,59 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Suppress Ink's clearTerminal (ESC[2J + ESC[3J + ESC[H]) during splash.
- *
- * When Ink's output fills the terminal, it uses ansi-escapes clearTerminal
- * on every frame. This sequence:
- *   ESC[2J  - erase display (iTerm2 pushes content to scrollback)
- *   ESC[3J  - erase scrollback (triggers iTerm2 warning)
- *   ESC[H   - cursor home
- *
- * We handle this in two phases:
- *
- * First frame:  ESC[2J + ESC[H  (push current screen to scrollback, then clear)
- *               This preserves the user's terminal history in scrollback.
- *
- * Later frames: ESC[H + ESC[J   (cursor home + erase to end of display)
- *               Overwrites in-place without pushing frames to scrollback.
- *
- * ESC[3J is always stripped — it's never needed and triggers iTerm2 warnings.
- */
-/**
- * The full clearTerminal sequence that Ink emits via ansi-escapes.
- * ESC[2J (erase display) + ESC[3J (erase scrollback) + ESC[H (cursor home)
- */
-const CLEAR_TERMINAL = '\x1b[2J\x1b[3J\x1b[H';
-/** First frame: push visible screen to scrollback, clear, cursor home. */
-const CLEAR_FIRST = '\x1b[2J\x1b[H';
-/** Later frames: cursor home, erase from cursor to end of display. */
-const CLEAR_SUBSEQUENT = '\x1b[H\x1b[J';
-let originalWrite = null;
-let firstFrame = true;
-/**
- * Patch stdout.write to replace clearTerminal with a scrollback-safe clear.
- * Safe to call multiple times — only patches once.
- */
-export function suppressScrollbackClear() {
-    if (originalWrite)
-        return; // Already patched
-    originalWrite = process.stdout.write;
-    const patched = function (chunk, ...args) {
-        if (typeof chunk === 'string' && chunk.includes(CLEAR_TERMINAL)) {
-            if (firstFrame) {
-                // First frame: use ESC[2J to push current screen to scrollback
-                firstFrame = false;
-                chunk = chunk.replace(CLEAR_TERMINAL, CLEAR_FIRST);
-            }
-            else {
-                // Subsequent frames: overwrite in-place, no scrollback push
-                chunk = chunk.replace(CLEAR_TERMINAL, CLEAR_SUBSEQUENT);
-            }
-        }
-        if (!originalWrite)
-            return false;
-        return originalWrite.apply(this, [chunk, ...args]);
-    };
-    process.stdout.write = patched;
-}
-//# sourceMappingURL=alternate-screen.js.map

package/dist/lib/api-client.js

@@ -1,154 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import axios from 'axios';
-import { getAuthToken, clearAuthToken } from './auth.js';
-import { retry, debug, GuildCLIError, ErrorCodes, shouldClearAuthToken, } from './errors.js';
-import { getUserAgent, getGuildcoreUrl } from './config.js';
-import { getIapHeaders } from './iap.js';
-/**
- * HTTP client for Guild API
- * Handles authentication, error handling, and request formatting
- */
-export class GuildAPIClient {
-    client;
-    baseUrl;
-    enableRetry;
-    maxRetries;
-    constructor(options = {}) {
-        this.baseUrl = options.baseUrl || getGuildcoreUrl();
-        this.enableRetry = options.enableRetry !== false; // Default: enabled
-        this.maxRetries = options.maxRetries || 3;
-        this.client = axios.create({
-            baseURL: this.baseUrl,
-            timeout: options.defaultTimeout || 30000,
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-                'User-Agent': getUserAgent(),
-            },
-        });
-        debug(`API Client initialized: ${this.baseUrl}, retry: ${this.enableRetry}, max retries: ${this.maxRetries}`);
-    }
-    /**
-     * Make an HTTP request with automatic auth header injection
-     * @param method - HTTP method
-     * @param endpoint - API endpoint path
-     * @param config - Axios request configuration
-     * @returns Response data
-     * @throws Error with specific error codes for proper error handling
-     */
-    async request(method, endpoint, config = {}) {
-        const makeRequest = async () => {
-            // Add IAP headers for IAP-protected hosts (*.guildai.dev)
-            // Uses Proxy-Authorization header so Authorization can be used for GuildCore auth
-            const iapHeaders = await getIapHeaders(this.baseUrl);
-            config.headers = {
-                ...config.headers,
-                ...iapHeaders,
-            };
-            // Add authentication header for authenticated endpoints
-            const requiresAuth = !endpoint.startsWith('/oauth/') && !endpoint.startsWith('/hello');
-            if (requiresAuth) {
-                const token = await getAuthToken();
-                if (!token) {
-                    throw new GuildCLIError(ErrorCodes.AUTH_REQUIRED, 'Authentication required. Please run: guild auth login');
-                }
-                config.headers = {
-                    ...config.headers,
-                    Authorization: `Bearer ${token}`,
-                };
-            }
-            debug(`Making ${method} request to ${endpoint}`);
-            try {
-                const response = await this.client.request({
-                    method,
-                    url: endpoint,
-                    ...config,
-                });
-                debug(`Request successful: ${method} ${endpoint}`);
-                return response.data;
-            }
-            catch (error) {
-                if (error &&
-                    typeof error === 'object' &&
-                    'response' in error &&
-                    error.response?.status === 401) {
-                    const resp = error.response;
-                    const data = resp?.data;
-                    const message = typeof data === 'object' && data && 'message' in data
-                        ? data.message
-                        : undefined;
-                    if (shouldClearAuthToken(message)) {
-                        debug('Guild auth failure (401), clearing token');
-                        await clearAuthToken();
-                        throw new GuildCLIError(ErrorCodes.AUTH_TOKEN_INVALID, 'Your authentication token is invalid or expired. Please run: guild auth login');
-                    }
-                    debug(`Non-auth 401: ${message ?? 'no message'}`);
-                }
-                throw error;
-            }
-        };
-        // Use retry logic if enabled
-        if (this.enableRetry) {
-            return await retry(makeRequest, {
-                maxAttempts: this.maxRetries,
-            });
-        }
-        else {
-            return await makeRequest();
-        }
-    }
-    /**
-     * Make a GET request
-     */
-    async get(endpoint, config) {
-        return this.request('GET', endpoint, config);
-    }
-    /**
-     * Make a POST request
-     */
-    async post(endpoint, data, config) {
-        return this.request('POST', endpoint, { ...config, data });
-    }
-    /**
-     * Make a PUT request
-     */
-    async put(endpoint, data, config) {
-        return this.request('PUT', endpoint, { ...config, data });
-    }
-    /**
-     * Make a PATCH request
-     */
-    async patch(endpoint, data, config) {
-        return this.request('PATCH', endpoint, { ...config, data });
-    }
-    /**
-     * Make a DELETE request
-     */
-    async delete(endpoint, config) {
-        return this.request('DELETE', endpoint, config);
-    }
-    /**
-     * Fetch all items from a paginated endpoint by paging through results.
-     * Use for display commands or ID-based lookups where you need the complete list.
-     *
-     * @param endpoint - API endpoint path (may include query params)
-     * @returns Flat array of all items across all pages
-     */
-    async fetchAll(endpoint) {
-        const PAGE_SIZE = 100;
-        const allItems = [];
-        let offset = 0;
-        while (true) {
-            const separator = endpoint.includes('?') ? '&' : '?';
-            const url = `${endpoint}${separator}limit=${PAGE_SIZE}&offset=${offset}`;
-            const response = await this.get(url);
-            allItems.push(...response.items);
-            offset += response.pagination.limit;
-            if (!response.pagination.has_more)
-                break;
-        }
-        return allItems;
-    }
-}
-//# sourceMappingURL=api-client.js.map

package/dist/lib/api-types.js

@@ -1,10 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-/** Default page size for standard list endpoints (matches backend). */
-export const DEFAULT_PAGE_LIMIT = 20;
-/** Default page size for high-volume endpoints (events, tasks, operations). */
-export const DEFAULT_PAGE_LIMIT_LARGE = 100;
-// Import and re-export generated types (from cli/scripts/sync-types-from-python.py)
-import { WEBHOOK_SERVICES, TIME_TRIGGER_FREQUENCIES, } from './generated-types.js';
-export { WEBHOOK_SERVICES, TIME_TRIGGER_FREQUENCIES, };
-//# sourceMappingURL=api-types.js.map