runcloud 0.2.179 → 0.2.182

package/dist/commands/github.js

@@ -0,0 +1,61 @@
+import { ApiClient, ApiError, friendlyApiError } from '../api.js';
+import { requireCredentials, resolveProject } from '../config.js';
+export async function getGithubStatus(client, projectId) {
+    return (await client.get(`/projects/${encodeURIComponent(projectId)}/github/status?ahead=1`));
+}
+export async function pullGithubBranch(client, projectId, branch) {
+    await client.post(`/projects/${encodeURIComponent(projectId)}/git/branches/${encodeURIComponent(branch)}/push`);
+}
+export function formatGithubBranches(status) {
+    if (!status.connected)
+        return 'This project is not linked to a GitHub repository.';
+    const repo = `${status.owner}/${status.name}`;
+    if (status.ahead === undefined)
+        return `Linked to ${repo}, but GitHub could not be read right now. Try again shortly.`;
+    if (status.ahead.length === 0)
+        return `Linked to ${repo}. Newly has every GitHub branch at its current tip.`;
+    return [
+        `Linked to ${repo}. On GitHub, not yet in Newly at their current tip:`,
+        ...status.ahead.map((b) => `  ${b}`),
+        'Bring one in with: newly github pull <branch>',
+    ].join('\n');
+}
+export function registerGithub(program) {
+    const github = program
+        .command('github')
+        .description("Work with the project's linked GitHub repository");
+    const run = (action) => async (opts) => {
+        try {
+            const creds = requireCredentials();
+            const projectId = resolveProject(process.cwd(), opts.project);
+            await action(new ApiClient(creds.apiUrl, creds.token), projectId);
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    };
+    github
+        .command('branches')
+        .description('List GitHub branches that Newly does not have yet (or has at an older tip)')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .action(run(async (client, projectId) => {
+        console.log(formatGithubBranches(await getGithubStatus(client, projectId)));
+    }));
+    github
+        .command('pull <branch>')
+        .description('Bring one GitHub branch into Newly (a two-way sync of that branch) so it can be fetched and checked out')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .action((branch, opts) => run(async (client, projectId) => {
+        try {
+            await pullGithubBranch(client, projectId, branch);
+        }
+        catch (e) {
+            if (e instanceof ApiError && e.status === 403) {
+                throw new Error(`Pulling ${branch} needs a project admin. Ask the user to pull it from the GitHub pane in the Deploy tab.`);
+            }
+            throw e;
+        }
+        console.log(`${branch} is in Newly, synced both ways with GitHub. Run: git fetch origin ${branch} && git checkout ${branch}`);
+    })(opts));
+}

package/dist/commands/run-cloud-fleet-observations.js

@@ -6,6 +6,13 @@ export const num = (value) => typeof value === 'number' && Number.isFinite(value
 export const stamp = (value) => str(value) && Number.isFinite(Date.parse(String(value))) ? new Date(String(value)).toISOString() : null;
 export const time = (value) => stamp(value) ? Date.parse(String(value)) : 0;
 export const validFleetId = (value) => typeof value === 'string' && /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,255}$/.test(value);
+export function fleetReadError(reason, timeoutMs) {
+    if (reason === 'HTTP 401' || reason === 'HTTP 403')
+        return new Error(`Fleet access denied (${reason}); use an admin identity with read permission`);
+    if (reason === 'request_deadline_exceeded')
+        return new Error(`Fleet read timed out after ${timeoutMs / 1000}s (request_deadline_exceeded); retry the read and check API latency if it persists`);
+    return new Error(`Fleet read unavailable (${reason ?? 'invalid_response'}); check API connectivity and retry the read`);
+}
 export function safeFleetText(value) {
     const text = str(value);
     return text ? text.slice(0, 8000)

package/dist/commands/run-cloud-fleet-survey.js

@@ -1,6 +1,6 @@
 import { ApiError } from '../api.js';
-import { componentHosts, hostReport, hostedObservation, num, observation, row, rows, safeFleetText, stamp, str, time, validFleetId } from './run-cloud-fleet-observations.js';
-export const SURVEY_REQUEST_BUDGET_MS = 8000;
+import { componentHosts, fleetReadError, hostReport, hostedObservation, num, observation, row, rows, safeFleetText, stamp, str, time, validFleetId } from './run-cloud-fleet-observations.js';
+export const SURVEY_REQUEST_BUDGET_MS = 30000;
 const ROOT = '/run-cloud/admin/simulators';
 const RANGES = ['1h', '6h', '24h', '7d'];
 const DEVICE_LIMIT = 512, POINT_LIMIT = 800, TYPE_LIMIT = 100;
@@ -122,19 +122,21 @@ export async function surveyFleet(client, options = {}, now, requestBudgetMs = S
         throw new Error('Invalid survey request budget');
     const started = performance.now(), signal = AbortSignal.timeout(requestBudgetMs);
     const read = async (path, key, body) => {
+        const sourceStarted = performance.now();
+        const timed = (source) => ({ ...source, durationSeconds: (performance.now() - sourceStarted) / 1000 });
         try {
             const value = body ? await client.post(path, body, { signal }) : await client.get(path, { signal });
             const data = row(value);
             if (value instanceof Response || !Array.isArray(data[key]))
-                return unavailable('invalid_response_shape');
+                return timed(unavailable('invalid_response_shape'));
             if (path === '/run-cloud/admin/jenkins' && data.state === 'unavailable')
-                return { state: 'unavailable', data, reason: 'jenkins_collection_unavailable' };
+                return timed({ state: 'unavailable', data, reason: 'jenkins_collection_unavailable' });
             if (path === '/run-cloud/admin/fleet-operations' && (data.unavailable === true || data.configured === false))
-                return { state: 'unavailable', data, reason: 'operation_storage_unavailable_or_unconfigured' };
-            return { state: 'available', data, reason: null };
+                return timed({ state: 'unavailable', data, reason: 'operation_storage_unavailable_or_unconfigured' });
+            return timed({ state: 'available', data, reason: null });
         }
         catch (error) {
-            return unavailable(error instanceof ApiError ? `HTTP ${error.status}` : signal.aborted ? 'request_budget_exhausted' : 'read_failed');
+            return timed(unavailable(error instanceof ApiError ? `HTTP ${error.status}` : signal.aborted ? 'request_deadline_exceeded' : 'read_failed'));
         }
     };
     const fleetPromise = read(ROOT, 'hosts');
@@ -163,7 +165,7 @@ export async function surveyFleet(client, options = {}, now, requestBudgetMs = S
         fleetPromise, inventoryPromise, sharedPromise, jenkinsPromise, operationsPromise, analyticsPromise, lagPromise,
     ]);
     if (fleet.state !== 'available')
-        throw new Error(`Fleet read unavailable (${fleet.reason}); use an admin identity with read permission`);
+        throw fleetReadError(fleet.reason, requestBudgetMs);
     now ??= Date.now();
     const live = new Map(rows(fleet.data.hosts).filter(host => validFleetId(host.id)).map(host => [String(host.id), host]));
     const canonical = new Map(rows(inventory.data.hosts).filter(host => validFleetId(host.id)).map(host => [String(host.id), host]));
@@ -187,7 +189,7 @@ export async function surveyFleet(client, options = {}, now, requestBudgetMs = S
     const alerts = alertReport(analytics, now, range, options.hostId);
     const sources = Object.fromEntries(Object.entries({ fleet, inventory, shared, jenkins, operations,
         analytics: { ...analytics, state: alerts.state, reason: alerts.reason }, inputLag: { ...lag, state: inputLag.state, reason: inputLag.reason } }).map(([key, source]) => [key, {
-            state: source.state, reason: source.reason, generatedAt: stamp(source.data.generatedAt ?? source.data.observedAt),
+            state: source.state, reason: source.reason, durationSeconds: source.durationSeconds ?? null, generatedAt: stamp(source.data.generatedAt ?? source.data.observedAt),
             responseAgeSeconds: stamp(source.data.generatedAt ?? source.data.observedAt) ? (now - time(source.data.generatedAt ?? source.data.observedAt)) / 1000 : null,
             meaning: 'response/collector generation time; does not renew component observations',
         }]));
@@ -214,8 +216,9 @@ export async function surveyFleet(client, options = {}, now, requestBudgetMs = S
 function age(value) { return `${value.state}, age ${value.ageSeconds === null ? 'unknown' : `${Math.round(value.ageSeconds)}s`}${value.reason ? `, ${value.reason}` : ''}`; }
 function bytes(value) { return value === null ? 'unknown' : `${(value / 1024 ** 3).toFixed(1)} GiB`; }
 export function surveyText(report) {
-    const lines = [`Fleet survey · ${report.scope} · ${report.generatedAt} · ${report.durationSeconds.toFixed(2)}s (request budget ${report.requestBudgetSeconds}s)`,
+    const lines = [`Fleet survey · ${report.scope} · ${report.generatedAt} · ${report.durationSeconds.toFixed(2)}s (read deadline ${report.requestBudgetSeconds}s)`,
         `${report.summary.hosts} machine records (${report.summary.canonicalHosts ?? 'unknown'} canonical); ${report.coverage.sourcesAvailable}/7 sources available.`,
+        `Source read times: ${Object.entries(report.sources).map(([name, source]) => `${name}=${source.durationSeconds === null ? 'not requested' : `${source.durationSeconds.toFixed(2)}s`}`).join(', ')}.`,
         `Diagnosis states: ${Object.entries(report.summary.diagnosisStates).map(([state, count]) => `${state}=${count}`).join(', ')}.`,
         `CPU mean: ${report.summary.cpu.meanBusyPercent?.toFixed(1) ?? 'unknown'}% from ${report.summary.cpu.freshHosts}/${report.summary.cpu.totalHosts} fresh host samples. ${report.summary.cpu.meaning}.`];
     if (report.alerts.state === 'available') {

package/dist/commands/run-cloud-fleet.js

@@ -1,4 +1,4 @@
-import { row, rows, str, num, stamp, time, pick, observation, componentHosts, hostReport, safeFleetText, validFleetId } from './run-cloud-fleet-observations.js';
+import { row, rows, str, num, stamp, time, pick, observation, componentHosts, fleetReadError, hostReport, safeFleetText, validFleetId } from './run-cloud-fleet-observations.js';
 export { safeFleetText } from './run-cloud-fleet-observations.js';
 import { readFileSync, statSync } from 'node:fs';
 import { ApiClient, ApiError } from '../api.js';
@@ -25,14 +25,15 @@ function validate(options) {
     bound(options.eventPages, 1, 10, 'event-pages');
 }
 async function readSource(client, path) {
+    const signal = AbortSignal.timeout(30000);
     try {
-        const data = await client.get(path, { signal: AbortSignal.timeout(30000) });
+        const data = await client.get(path, { signal });
         if (!data || typeof data !== 'object' || Array.isArray(data) || data instanceof Response)
             return { state: 'unavailable', data: {}, reason: 'invalid_json_response' };
         return { state: 'available', data: row(data), reason: null };
     }
     catch (error) {
-        return { state: 'unavailable', data: {}, reason: error instanceof ApiError ? `HTTP ${error.status}` : 'read_failed' };
+        return { state: 'unavailable', data: {}, reason: error instanceof ApiError ? `HTTP ${error.status}` : signal.aborted ? 'request_deadline_exceeded' : 'read_failed' };
     }
 }
 export async function readFleetEvents(client, options = {}) {
@@ -169,7 +170,7 @@ export async function inspectFleet(client, options = {}, now) {
         query.set('include', 'details');
     const fleet = await readSource(client, ROOT);
     if (fleet.state === 'unavailable' || !Array.isArray(fleet.data.hosts))
-        throw new Error(`Fleet read unavailable (${fleet.reason ?? 'invalid_response'}); use an admin identity with read permission`);
+        throw fleetReadError(fleet.reason, 30000);
     const [shared, diagnostics, events, history, jenkins] = await Promise.all([
         readSource(client, `${ROOT}/operator-inventory`),
         readSource(client, `${ROOT}/diagnostics?${query}`),

package/dist/index.js

@@ -10,6 +10,7 @@ import { registerPull } from './commands/pull.js';
 import { registerDeploy } from './commands/deploy.js';
 import { registerMisc } from './commands/misc.js';
 import { registerStack } from './commands/stack.js';
+import { registerGithub } from './commands/github.js';
 import { registerCreds } from './commands/creds.js';
 import { registerBuild } from './commands/build.js';
 import { registerServices } from './commands/services.js';
@@ -37,6 +38,7 @@ registerDeploy(program);
 registerAi(program);
 registerMisc(program);
 registerStack(program);
+registerGithub(program);
 registerCreds(program);
 registerBuild(program);
 registerServices(program);

package/dist/version.js

@@ -1 +1 @@
-export const CLI_VERSION = '0.2.179';
+export const CLI_VERSION = '0.2.182';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runcloud",
-  "version": "0.2.179",
+  "version": "0.2.182",
   "description": "Create and control run.cloud remote mobile simulators and cloud sandboxes",
   "license": "Apache-2.0",
   "keywords": [