@gaia-ai/core 0.6.0 → 0.6.2

package/dist/src/plugins/remote/drupal.js

@@ -1,393 +0,0 @@
-import { resolveAuth } from 'dropsh';
-import { createHttpClient, createJsonApiClient } from 'dropsh/plugin';
-const ACTIVE = ['claimed', 'running'];
-export class DrupalGaiaRemote {
-    api;
-    constructor(api) {
-        this.api = api;
-    }
-    async fetchActiveRuns(id) {
-        // The conductor identity `id` is the machine_id (hash of hostname+path).
-        // gaia_run links to its owning conductor via the `conductor_id` entity-ref;
-        // filter on the related conductor's `machine_id` (nested relationship filter).
-        const rows = await this.api
-            .collection('gaia_run')
-            .where('conductor_id.machine_id', '=', id)
-            .whereIn('state', ACTIVE)
-            .fields(['state', 'state_at_start', 'worktree_path'])
-            .page(100)
-            .list();
-        return Promise.all(rows.map(async (r) => ({
-            runUuid: r.id,
-            ticketUuid: r.rel('ticket_id') ?? '',
-            ticketIdentifier: await this.getRunTicketIdentifier(r.id),
-            branchName: await this.getRunTicketBranchName(r.id),
-            state: r.attr('state') ?? '',
-            stateAtStart: r.attr('state_at_start') ?? '',
-            worktreePath: r.attr('worktree_path') ?? '',
-        })));
-    }
-    async activeRunCount(id) {
-        // Filter on the related conductor's `machine_id` (nested relationship filter).
-        return this.api
-            .collection('gaia_run')
-            .where('conductor_id.machine_id', '=', id)
-            .whereIn('state', ACTIVE)
-            .fields(['drupal_internal__id'])
-            .page(100)
-            .count();
-    }
-    async claimNext(c) {
-        const res = (await this.api.post('gaia/claim-next', {
-            data: {
-                attributes: {
-                    lease_seconds: c.leaseSeconds,
-                    // Server (`ConductorResolverTrait`) narrows to the caller's conductor
-                    // by the `machine_id` attribute; `c.conductorId` IS the machine_id.
-                    machine_id: c.conductorId,
-                },
-            },
-        }));
-        if (!res?.data) {
-            return null;
-        }
-        const d = res.data;
-        const rawId = d.attributes?.drupal_internal__id;
-        if (rawId === undefined || rawId === null) {
-            throw new Error(`claimNext: missing drupal_internal__id on run ${d.id}`);
-        }
-        return {
-            runUuid: d.id,
-            runId: Number(rawId),
-            ticketUuid: d.relationships?.ticket_id?.data?.id ?? '',
-            stateAtStart: String(d.attributes?.state_at_start ?? ''),
-            // handler_id was dropped; the handler is the work the run does, i.e. the
-            // ticket state the run started in.
-            handler: String(d.attributes?.state_at_start ?? ''),
-        };
-    }
-    async getTicket(uuid) {
-        // The agent self-reads the ticket + its comments at run start (GAIA-112),
-        // so getTicket needs no ?include=comments — but it DOES sideload labels +
-        // environments (GAIA-144) so a config-side priority(ticket) can read them
-        // without fetching (AC-5).
-        const doc = (await this.api.get(`gaia_ticket/gaia_ticket/${uuid}?include=labels,environments`));
-        const attrs = doc.data?.attributes ?? {};
-        const issueUrl = typeof attrs.origin === 'string' ? attrs.origin : undefined;
-        const included = Array.isArray(doc.included) ? doc.included : [];
-        const byId = new Map(included.map((r) => [`${r.type}:${r.id}`, r]));
-        const refs = (name) => {
-            const data = doc.data?.relationships?.[name]?.data;
-            return Array.isArray(data) ? data : [];
-        };
-        const labels = refs('labels')
-            .map((ref) => byId.get(`${ref.type}:${ref.id}`)?.attributes?.name)
-            .filter((n) => typeof n === 'string');
-        const environments = refs('environments')
-            .map((ref) => {
-            const a = byId.get(`${ref.type}:${ref.id}`)?.attributes ?? {};
-            return {
-                name: typeof a.name === 'string' ? a.name : '',
-                tier: typeof a.tier === 'string' ? a.tier : '',
-            };
-        })
-            .filter((e) => e.name !== '');
-        return {
-            uuid: doc.data?.id ?? uuid,
-            identifier: typeof attrs.identifier === 'string' ? attrs.identifier : uuid,
-            title: typeof attrs.title === 'string' ? attrs.title : '',
-            state: typeof attrs.state === 'string' ? attrs.state : '',
-            branchName: typeof attrs.branch_name === 'string' ? attrs.branch_name : '',
-            ...(typeof attrs.base_branch === 'string' && attrs.base_branch !== ''
-                ? { baseBranch: attrs.base_branch }
-                : {}),
-            ...(typeof attrs.effective_env_vars === 'string' &&
-                attrs.effective_env_vars !== ''
-                ? { effectiveEnvVars: attrs.effective_env_vars }
-                : {}),
-            ...(issueUrl ? { issueUrl } : {}),
-            labels,
-            environments,
-        };
-    }
-    async getRunWorktree(uuid) {
-        const r = await this.api.resource('gaia_run', uuid);
-        return r.attr('worktree_path') ?? '';
-    }
-    async getRunTicketIdentifier(uuid) {
-        const run = await this.api.resource('gaia_run', uuid);
-        const ticketUuid = run.rel('ticket_id');
-        if (!ticketUuid) {
-            return '';
-        }
-        const ticket = await this.api.resource('gaia_ticket', ticketUuid);
-        return ticket.attr('identifier') ?? '';
-    }
-    async getRunTicketBranchName(uuid) {
-        const run = await this.api.resource('gaia_run', uuid);
-        const ticketUuid = run.rel('ticket_id');
-        if (!ticketUuid) {
-            return '';
-        }
-        const ticket = await this.api.resource('gaia_ticket', ticketUuid);
-        return ticket.attr('branch_name') ?? '';
-    }
-    async registerConductor(reg) {
-        const r = await this.api.upsert('gaia_conductor', { path: 'machine_id', value: reg.id }, {
-            attributes: {
-                machine_id: reg.id,
-                status: 'online',
-                workspace_root: reg.workspace,
-                label: reg.label,
-                states: reg.states,
-                max_parallel: reg.max_parallel,
-            },
-            relationships: {
-                owner_user_id: {
-                    data: { type: 'user--user', id: await this.api.me() },
-                },
-                project_id: {
-                    data: {
-                        type: 'gaia_project--gaia_project',
-                        id: await this.projectUuid(reg.project),
-                    },
-                },
-            },
-        });
-        return r.id; // drupal uuid
-    }
-    async heartbeat(reg, load, lease = 300) {
-        // Server-side upsert by machine_id (see HeartbeatResource): never 404s,
-        // heals a vanished registration, and returns the resulting status. Sending
-        // the full registration lets the server recreate the entity when missing.
-        const res = (await this.api.post('gaia/heartbeat', {
-            data: {
-                attributes: {
-                    machine_id: reg.id,
-                    project: reg.project,
-                    states: reg.states,
-                    workspace_root: reg.workspace,
-                    label: reg.label,
-                    max_parallel: reg.max_parallel,
-                    current_load: load,
-                    lease_seconds: lease,
-                },
-            },
-        }));
-        const status = res?.data?.attributes?.status;
-        return typeof status === 'string' ? status : 'online';
-    }
-    async getConductorStatus(id) {
-        const c = await this.api
-            .collection('gaia_conductor')
-            .where('machine_id', '=', id)
-            .fields(['status'])
-            .first();
-        return c ? (c.attr('status') ?? null) : null;
-    }
-    async setConductorStatus(id, status) {
-        const c = await this.api
-            .collection('gaia_conductor')
-            .where('machine_id', '=', id)
-            .first();
-        if (c) {
-            await this.api.update('gaia_conductor', c.id, { attributes: { status } });
-        }
-    }
-    async listConductors(owner) {
-        let col = this.api.collection('gaia_conductor');
-        if (owner === 'me') {
-            col = col.where('owner_user_id.id', '=', await this.api.me());
-        }
-        const rows = await col.page(200).list();
-        return rows.map((r) => ({
-            id: r.attr('machine_id') ?? r.id,
-            project: '',
-            label: r.attr('label') ?? '',
-            status: r.attr('status') ?? '',
-            lastSeen: r.attr('last_seen') ?? 0,
-            load: r.attr('current_load') ?? 0,
-        }));
-    }
-    async markRunning(uuid, attrs) {
-        const t = Math.floor(Date.now() / 1000);
-        await this.api.update('gaia_run', uuid, {
-            attributes: {
-                state: 'running',
-                heartbeat: t,
-                ...(attrs?.worktree_path ? { worktree_path: attrs.worktree_path } : {}),
-                ...(attrs?.agent ? { agent: attrs.agent } : {}),
-            },
-        });
-    }
-    async markFailed(uuid, errorLog) {
-        const t = Math.floor(Date.now() / 1000);
-        await this.api.update('gaia_run', uuid, {
-            attributes: {
-                state: 'failed',
-                error_log: errorLog,
-                closed: true,
-                closed_date: t,
-            },
-        });
-    }
-    async fetchFinalizableRuns(id) {
-        const rows = await this.api
-            .collection('gaia_run')
-            .where('conductor_id.machine_id', '=', id)
-            .where('state', '=', 'done')
-            .where('closed', '=', '0')
-            .fields(['worktree_path', 'agent', 'drupal_internal__id'])
-            .page(100)
-            .list();
-        // No `started_at` read: the run's duration_s is derived from the agent
-        // transcript at finalize (GAIA-151), so the conductor no longer round-trips
-        // the timestamp back through JSON:API.
-        return rows.map((r) => ({
-            runUuid: r.id,
-            // The `#<runId>` tab-label token: scopes the run's tab-close (GAIA-183).
-            runId: Number(r.attr('drupal_internal__id')),
-            worktreePath: r.attr('worktree_path') ?? '',
-            agent: r.attr('agent') ?? '',
-        }));
-    }
-    async finalizeRun(uuid, log, metrics) {
-        const t = Math.floor(Date.now() / 1000);
-        await this.api.update('gaia_run', uuid, {
-            attributes: {
-                closed: true,
-                closed_date: t,
-                ...(log ? { log } : {}),
-                ...(metrics ?? {}),
-            },
-        }); // NO state — the run is already done.
-    }
-    async fetchUncleanedTickets(id) {
-        // Finished tickets whose worktree is not yet torn down (cleaned_up=0),
-        // driven by the durable `cleaned_up` flag (GAIA-89) AND scoped to this
-        // conductor (GAIA-121): only tickets assigned to `id` are loaded, so a
-        // ticket owned by another conductor never reaches the reaper loop. "Finished"
-        // = reached `done` OR already `closed`; the collection builder has no OR, so
-        // this is two AND-queries merged + de-duped by uuid. The `conductor_id`
-        // relationship carries the assigned conductor's `machine_id` — the same
-        // nested filter the sibling reaper queries (`fetchFinalizableRuns` etc.) use.
-        const fields = ['branch_name', 'state', 'closed'];
-        const done = await this.api
-            .collection('gaia_ticket')
-            .where('conductor_id.machine_id', '=', id)
-            .where('state', '=', 'done')
-            .where('cleaned_up', '=', '0')
-            .fields(fields)
-            .page(100)
-            .list();
-        const closed = await this.api
-            .collection('gaia_ticket')
-            .where('conductor_id.machine_id', '=', id)
-            .where('closed', '=', '1')
-            .where('cleaned_up', '=', '0')
-            .fields(fields)
-            .page(100)
-            .list();
-        const byUuid = new Map();
-        for (const r of [...done, ...closed]) {
-            byUuid.set(r.id, r);
-        }
-        return Promise.all([...byUuid.values()].map(async (r) => ({
-            ticketUuid: r.id,
-            branchName: r.attr('branch_name') ?? '',
-            state: r.attr('state') ?? '',
-            closed: r.attr('closed') ?? false,
-            worktreePath: await this.latestRunWorktree(r.id),
-        })));
-    }
-    async closeTicket(uuid) {
-        const t = Math.floor(Date.now() / 1000);
-        await this.api.update('gaia_ticket', uuid, {
-            attributes: { closed: true, closed_date: t },
-        }); // NO state — the ticket is already done.
-    }
-    async markTicketCleanedUp(uuid) {
-        await this.api.update('gaia_ticket', uuid, {
-            attributes: { cleaned_up: true },
-        }); // NO state/closed — teardown flag only, decoupled from the lifecycle.
-    }
-    /**
-     * Absolute worktree path of the ticket's latest run (highest run id with a
-     * non-empty worktree_path), or '' when none — the cwd the cleanup command
-     * runs in. The conductor persists worktree_path on markRunning, so a done
-     * ticket's run carries the path even after the run closed.
-     */
-    async latestRunWorktree(ticketUuid) {
-        const rows = await this.api
-            .collection('gaia_run')
-            .where('ticket_id.id', '=', ticketUuid)
-            .fields(['worktree_path', 'drupal_internal__id'])
-            .sort('-drupal_internal__id')
-            .page(100)
-            .list();
-        for (const r of rows) {
-            const path = r.attr('worktree_path');
-            if (path) {
-                return path;
-            }
-        }
-        return '';
-    }
-    async resolveTicketByIdentifier(project, identifier) {
-        // Scope by the project uuid: identifiers (GAIA-nnn) are unique per project,
-        // not globally, so a bare identifier filter could match another project's
-        // ticket in a multi-project instance.
-        const projectId = await this.projectUuid(project);
-        const t = await this.api
-            .collection('gaia_ticket')
-            .where('identifier', '=', identifier)
-            .where('project_id.id', '=', projectId)
-            .first();
-        if (!t) {
-            return null;
-        }
-        return { uuid: t.id, title: t.attr('title') ?? '' };
-    }
-    projectUuidCache = new Map();
-    async projectUuid(name) {
-        // A project's name→uuid never changes, so cache it: gatherBatch resolves
-        // many identifiers per `gaia deployment tickets` call, each of which would
-        // otherwise re-fetch the same project.
-        const cached = this.projectUuidCache.get(name);
-        if (cached) {
-            return cached;
-        }
-        const p = await this.api
-            .collection('gaia_project')
-            .where('name', '=', name)
-            .first();
-        if (!p) {
-            throw new Error(`gaia project "${name}" not found`);
-        }
-        this.projectUuidCache.set(name, p.id);
-        return p.id;
-    }
-}
-export function drupalRemote() {
-    return {
-        kind: 'remote',
-        id: 'drupal',
-        requiredModules: [],
-        async createRemote(config) {
-            const http = createHttpClient();
-            const auth = await resolveAuth({
-                baseUrl: config.site.base_url,
-                plugins: config.plugins ?? [],
-                http,
-                now: Date.now,
-                // stateDir omitted → dropsh defaultStateDir() (~/.config/dropsh)
-            });
-            return new DrupalGaiaRemote(createJsonApiClient({
-                baseUrl: config.site.base_url,
-                prefix: config.site.jsonapi_prefix,
-                http,
-                auth: auth,
-            }));
-        },
-    };
-}

package/dist/src/plugins/remote/fake.d.ts

@@ -1,113 +0,0 @@
-import type { RemotePlugin } from '../plugins.js';
-import type { ActiveRun, ClaimedRun, ClaimOptions, ConductorRegistration, ConductorStatus, FinalizableRun, GaiaRemote, RunMetrics, RunWriteAttributes, Ticket, UncleanTicket } from './remote.js';
-export interface FakeSeedRun {
-    runUuid: string;
-    /** Numeric (drupal_internal__id) run id. Defaults to a stable 1-based counter when omitted. */
-    id?: number;
-    ticketUuid: string;
-    stateAtStart: string;
-    /** Override the initial state (defaults to stateAtStart). */
-    state?: string;
-    handler?: string;
-    worktreePath?: string;
-    closed?: boolean;
-    /** Id of the agent that ran (GAIA-144) — routes footprint parsing at finalize. */
-    agent?: string;
-}
-export interface FakeSeedTicket {
-    identifier: string;
-    title: string;
-    state: string;
-    branchName?: string;
-    /** Computed base branch (parent branch / project default / 'main'). */
-    baseBranch?: string;
-    /** Effective env vars (parent-chain resolved) as `.env`-style lines. */
-    effectiveEnvVars?: string;
-    url?: string;
-    workflow?: string;
-    /** Label term names sideloaded for agent selection (GAIA-144). */
-    labels?: string[];
-    /** Environments sideloaded for agent selection (GAIA-144). */
-    environments?: {
-        name: string;
-        tier: string;
-    }[];
-    /** Whether the ticket is already closed (its lifecycle wound up). */
-    closed?: boolean;
-    /** Whether the ticket's worktree is already torn down (cleaned_up flag). */
-    cleanedUp?: boolean;
-    /**
-     * machine_id of the conductor this ticket is assigned to (GAIA-121). Omit to
-     * mean "belongs to the querying conductor" (the common case for reaper tests);
-     * set an explicit value to test conductor-scoping, or `''` for unassigned.
-     */
-    conductorId?: string;
-}
-export interface FakeRemoteSeed {
-    runs?: FakeSeedRun[];
-    tickets?: Record<string, FakeSeedTicket>;
-}
-export interface MarkRunningCall {
-    runUuid: string;
-    attrs?: {
-        worktree_path?: string;
-        agent?: string;
-    };
-}
-export interface FinalizeRunCall {
-    runUuid: string;
-    log: string;
-    metrics?: RunMetrics;
-}
-export interface MarkFailedCall {
-    runUuid: string;
-    errorLog: string;
-}
-export declare class FakeGaiaRemote implements GaiaRemote {
-    readonly calls: {
-        markRunning: MarkRunningCall[];
-        markFailed: MarkFailedCall[];
-        finalizeRun: FinalizeRunCall[];
-        closeTicket: string[];
-        markCleanedUp: string[];
-    };
-    /**
-     * Override for reconcile tests: when set, `fetchActiveRuns` returns this
-     * list verbatim instead of deriving it from the internal runs map.
-     */
-    activeRuns: ActiveRun[] | null;
-    private readonly runs;
-    private readonly queue;
-    private readonly tickets;
-    private conductorStatus;
-    /** Stable counter for assigning numeric ids to unseeded runs. */
-    private runIdCounter;
-    constructor(seed?: FakeRemoteSeed);
-    registerConductor(_reg: ConductorRegistration): Promise<string>;
-    heartbeat(): Promise<string>;
-    getConductorStatus(_conductorId: string): Promise<string | null>;
-    setConductorStatus(_conductorId: string, status: 'offline' | 'online'): Promise<void>;
-    listConductors(_owner?: 'me'): Promise<ConductorStatus[]>;
-    activeRunCount(_conductorId: string): Promise<number>;
-    fetchActiveRuns(_conductorId: string): Promise<ActiveRun[]>;
-    claimNext(_claim: ClaimOptions): Promise<ClaimedRun | null>;
-    getTicket(ticketUuid: string): Promise<Ticket>;
-    getRunWorktree(runUuid: string): Promise<string>;
-    getRunTicketIdentifier(runUuid: string): Promise<string>;
-    getRunTicketBranchName(runUuid: string): Promise<string>;
-    markRunning(runUuid: string, attrs?: RunWriteAttributes): Promise<void>;
-    markFailed(runUuid: string, errorLog: string): Promise<void>;
-    fetchFinalizableRuns(_conductorId: string): Promise<FinalizableRun[]>;
-    finalizeRun(runUuid: string, log: string, metrics?: RunMetrics): Promise<void>;
-    fetchUncleanedTickets(conductorId: string): Promise<UncleanTicket[]>;
-    closeTicket(uuid: string): Promise<void>;
-    markTicketCleanedUp(uuid: string): Promise<void>;
-    resolveTicketByIdentifier(_project: string, identifier: string): Promise<{
-        uuid: string;
-        title: string;
-    } | null>;
-    /** Worktree path of the ticket's most recently seeded run, or '' when none. */
-    private latestRunWorktree;
-    private internalActiveRuns;
-}
-export declare function fakeRemote(seed?: FakeRemoteSeed): RemotePlugin;