@google-cloud/kcmd 0.0.0-stage → 0.1.0

package/build/ts/kcmd/gcp/alloydb.d.ts

@@ -0,0 +1,12 @@
+import * as api from './api';
+import * as context from './context';
+export interface Instance {
+    name?: string;
+    instanceType?: string;
+    state?: string;
+    [key: string]: any;
+}
+export declare class AlloyDbClient extends api.ApiClient {
+    constructor(ctx: context.ApiContext);
+    listInstances(project: string, location: string, cluster: string): Promise<api.ApiResult<Instance[]>>;
+}

package/build/ts/kcmd/gcp/alloydb.js

@@ -0,0 +1,70 @@
+"use strict";
+// API client for AlloyDB, covering the one call the semantic runtime needs:
+// listing a cluster's instances, to find the primary instance a connection to
+// one of the cluster's databases goes through.
+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.AlloyDbClient = void 0;
+const api = __importStar(require("./api"));
+class AlloyDbClient extends api.ApiClient {
+    constructor(ctx) {
+        super('https://alloydb.googleapis.com', 'v1', ctx);
+    }
+    // Lists every instance in a cluster. Follows nextPageToken until exhausted
+    // and returns the flat list. A non-200 on any page aborts and is returned
+    // as-is. Throws when the server repeats a page token, which would otherwise
+    // never end.
+    async listInstances(project, location, cluster) {
+        const parent = `projects/${project}/locations/${location}/clusters/${cluster}/instances`;
+        const instances = [];
+        let pageToken = undefined;
+        const seen = new Set();
+        do {
+            const res = await this._get(parent, { pageToken });
+            if (res.status != 200) {
+                return { status: res.status, message: res.message, body: res.body };
+            }
+            instances.push(...(res.result?.instances ?? []));
+            pageToken = res.result?.nextPageToken;
+            if (pageToken && seen.has(pageToken)) {
+                throw new Error(`the AlloyDB API returned page token '${pageToken}' twice`);
+            }
+            if (pageToken)
+                seen.add(pageToken);
+        } while (pageToken);
+        return { status: 200, result: instances };
+    }
+}
+exports.AlloyDbClient = AlloyDbClient;

package/build/ts/kcmd/gcp/api.d.ts

@@ -0,0 +1,29 @@
+import * as context from './context';
+export interface ApiResult<T> {
+    status: number;
+    result?: T;
+    message?: string;
+    body?: string;
+}
+export interface ApiClientOptions {
+    retryDelayMs?: number;
+}
+export interface RequestOptions {
+    retry?: boolean;
+}
+export declare function errorMessage(body: string): string;
+export declare function isTransientStatus(status: number): boolean;
+export declare class ApiClient {
+    private readonly _endpoint;
+    private readonly _pathPrefix;
+    private readonly _context;
+    private readonly _retryDelayMs?;
+    constructor(endpoint: string, pathPrefix: string, context: context.ApiContext, options?: ApiClientOptions);
+    get context(): context.ApiContext;
+    _get<T>(resourceName: string, queryParams?: Record<string, any>, options?: RequestOptions): Promise<ApiResult<T>>;
+    _post<T>(resourceName: string, body: any, queryParams?: Record<string, any>): Promise<ApiResult<T>>;
+    _patch<T>(resourceName: string, body: any, queryParams?: Record<string, any>): Promise<ApiResult<T>>;
+    _delete<T>(resourceName: string, queryParams?: Record<string, any>): Promise<ApiResult<T>>;
+    private _requestRetry;
+    private _requestCore;
+}

package/build/ts/kcmd/gcp/api.js

@@ -0,0 +1,162 @@
+"use strict";
+// API Client base class
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+exports.errorMessage = errorMessage;
+exports.isTransientStatus = isTransientStatus;
+const TRANSIENT_TRIES = 4;
+const TRANSIENT_DELAY_CAP_MS = 5000;
+const MAX_MESSAGE_LENGTH = 2000;
+// The message in a failed response's body. For a Google API error it is the
+// LocalizedMessage detail, which Spanner leaves unescaped, or else
+// `error.message`. Each BadRequest field violation that the message does not
+// state is appended, with its line breaks replaced by semicolons. Any other
+// body comes back trimmed and cut to 2,000 characters. An HTML page comes back
+// as its text.
+function errorMessage(body) {
+    const text = body.trim();
+    try {
+        const error = JSON.parse(text)?.error;
+        const details = Array.isArray(error?.details) ? error.details : [];
+        const localized = details.find((d) => d?.['@type']?.endsWith('LocalizedMessage') && isText(d.message));
+        const message = localized?.message ?? error?.message;
+        if (isText(message)) {
+            // Spanner states what is wrong with a name, such as an uppercase
+            // database ID, only in a field violation.
+            const violations = details
+                .filter((d) => d?.['@type']?.endsWith('BadRequest'))
+                .flatMap((d) => Array.isArray(d.fieldViolations) ? d.fieldViolations : [])
+                .map((v) => v?.description)
+                .filter((v) => isText(v) && !message.includes(v.trim()))
+                .map((v) => v.trim().replace(/\s*\n\s*/g, '; '));
+            return [message.trim(), ...violations].join(' ');
+        }
+    }
+    catch {
+        // Not JSON, such as a proxy's HTML error page.
+    }
+    const plain = text.startsWith('<') ?
+        text.replace(/<(style|script)\b[\s\S]*?<\/\1>/gi, ' ')
+            .replace(/<[^>]*>/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim() :
+        text;
+    return plain.length > MAX_MESSAGE_LENGTH ?
+        `${plain.slice(0, MAX_MESSAGE_LENGTH)}...` : plain;
+}
+function isText(value) {
+    return typeof value === 'string' && value.trim() !== '';
+}
+function isTransientStatus(status) {
+    return status >= 500 || status === 429;
+}
+function transientDelayMs(configured) {
+    if (configured !== undefined && Number.isFinite(configured) && configured >= 0) {
+        return configured;
+    }
+    const raw = process.env.GCP_RETRY_DELAY_MS;
+    if (raw !== undefined && raw.trim() !== '') {
+        const parsed = Number(raw);
+        if (Number.isFinite(parsed) && parsed >= 0)
+            return parsed;
+    }
+    return 500;
+}
+function jitteredDelay(delayMs) {
+    return delayMs > 0 ? Math.round(delayMs * (0.5 + Math.random() * 0.5)) : 0;
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+class ApiClient {
+    _endpoint;
+    _pathPrefix;
+    _context;
+    _retryDelayMs;
+    constructor(endpoint, pathPrefix, context, options = {}) {
+        this._endpoint = endpoint;
+        this._pathPrefix = pathPrefix;
+        this._context = context;
+        this._retryDelayMs = options.retryDelayMs;
+    }
+    get context() {
+        return this._context;
+    }
+    // Only reads retry: a write that 5xxs may still have landed on the server.
+    async _get(resourceName, queryParams, options) {
+        const url = `${this._endpoint}/${this._pathPrefix}/${resourceName}`;
+        return this._requestRetry('GET', url, queryParams, undefined, options?.retry !== false);
+    }
+    async _post(resourceName, body, queryParams) {
+        const url = `${this._endpoint}/${this._pathPrefix}/${resourceName}`;
+        return this._requestRetry('POST', url, queryParams, body);
+    }
+    async _patch(resourceName, body, queryParams) {
+        const url = `${this._endpoint}/${this._pathPrefix}/${resourceName}`;
+        return this._requestRetry('PATCH', url, queryParams, body);
+    }
+    async _delete(resourceName, queryParams) {
+        const url = `${this._endpoint}/${this._pathPrefix}/${resourceName}`;
+        return this._requestRetry('DELETE', url, queryParams);
+    }
+    async _requestRetry(method, url, queryParams, body, retryTransient = false) {
+        if (queryParams) {
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(queryParams)) {
+                if (value !== undefined) {
+                    if (Array.isArray(value)) {
+                        value.forEach(v => params.append(key, String(v)));
+                    }
+                    else {
+                        params.append(key, String(value));
+                    }
+                }
+            }
+            const queryString = params.toString();
+            if (queryString) {
+                url += `?${queryString}`;
+            }
+        }
+        const tries = retryTransient ? TRANSIENT_TRIES : 1;
+        let delayMs = transientDelayMs(this._retryDelayMs);
+        let response;
+        for (let attempt = 0; attempt < tries; attempt++) {
+            if (attempt > 0) {
+                await sleep(jitteredDelay(delayMs));
+                delayMs = Math.min(delayMs * 2, TRANSIENT_DELAY_CAP_MS);
+            }
+            this._context.log(`${method} ${url}${body ? '\n' : ''}`, body);
+            response = await this._requestCore(url, { method, body });
+            if (response.status === 401) {
+                this.context.refresh();
+                response = await this._requestCore(url, { method, body });
+            }
+            if (!isTransientStatus(response.status))
+                break;
+        }
+        const result = { status: response.status };
+        if (!response.ok) {
+            result.body = await response.text();
+            result.message = errorMessage(result.body);
+        }
+        else {
+            result.result = await response.json();
+        }
+        this._context.log(`${response.status}:${result.body ?? ''}\n`, result.result);
+        return result;
+    }
+    async _requestCore(url, options) {
+        const headers = {
+            ...options.headers,
+            'Authorization': `Bearer ${this._context.token}`,
+            'Content-Type': 'application/json'
+        };
+        return fetch(url, {
+            ...options,
+            headers,
+            body: options.body ? JSON.stringify(options.body) : undefined,
+        });
+    }
+}
+exports.ApiClient = ApiClient;

package/build/ts/kcmd/gcp/biglake.d.ts

@@ -0,0 +1,16 @@
+import * as api from './api';
+import * as context from './context';
+export interface Catalog {
+    name?: string;
+    'catalog-type'?: string;
+    replicas?: Array<{
+        region?: string;
+        state?: string;
+    }>;
+    'storage-regions'?: string[];
+    [key: string]: any;
+}
+export declare class BigLakeClient extends api.ApiClient {
+    constructor(ctx: context.ApiContext);
+    getCatalog(project: string, catalog: string): Promise<api.ApiResult<Catalog>>;
+}

package/build/ts/kcmd/gcp/biglake.js

@@ -0,0 +1,50 @@
+"use strict";
+// API client for BigLake, covering the one call the source check needs:
+// reading an Iceberg REST catalog, whose region decides where Knowledge
+// Catalog keeps the entries of its tables.
+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.BigLakeClient = void 0;
+const api = __importStar(require("./api"));
+class BigLakeClient extends api.ApiClient {
+    constructor(ctx) {
+        super('https://biglake.googleapis.com', 'iceberg/v1/restcatalog/extensions', ctx);
+    }
+    // Fetches a catalog. A catalog that does not exist answers 404.
+    async getCatalog(project, catalog) {
+        return await this._get(`projects/${project}/catalogs/${catalog}`);
+    }
+}
+exports.BigLakeClient = BigLakeClient;

package/build/ts/kcmd/gcp/bigquery.d.ts

@@ -0,0 +1,57 @@
+import * as api from './api';
+import * as context from './context';
+export interface Dataset {
+    id: string;
+    datasetReference: {
+        projectId: string;
+        datasetId: string;
+    };
+    location: string;
+    [key: string]: any;
+}
+export interface Table {
+    id: string;
+    tableReference: {
+        projectId: string;
+        datasetId: string;
+        tableId: string;
+    };
+    location?: string;
+    [key: string]: any;
+}
+export interface QueryResponse {
+    jobComplete?: boolean;
+    jobReference?: {
+        projectId?: string;
+        jobId?: string;
+        location?: string;
+    };
+    errors?: {
+        reason?: string;
+        message: string;
+    }[];
+    [key: string]: any;
+}
+export interface Job {
+    status?: {
+        state?: string;
+        errorResult?: {
+            reason?: string;
+            message: string;
+        };
+        errors?: {
+            reason?: string;
+            message: string;
+        }[];
+    };
+    [key: string]: any;
+}
+export declare class BigQueryClient extends api.ApiClient {
+    constructor(ctx: context.ApiContext);
+    getDataset(project: string, dataset: string): Promise<api.ApiResult<Dataset>>;
+    getTable(project: string, dataset: string, table: string): Promise<api.ApiResult<Table>>;
+    listTables(project: string, dataset: string): AsyncGenerator<Table>;
+    query(project: string, sql: string, location?: string, dryRun?: boolean, namedParameterTypes?: Record<string, string>): Promise<api.ApiResult<QueryResponse>>;
+    getQueryResults(project: string, jobId: string, location?: string): Promise<api.ApiResult<QueryResponse>>;
+    getJob(project: string, jobId: string, location?: string): Promise<api.ApiResult<Job>>;
+}

package/build/ts/kcmd/gcp/bigquery.js

@@ -0,0 +1,134 @@
+"use strict";
+// API client for BigQuery
+//
+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.BigQueryClient = void 0;
+const api = __importStar(require("./api"));
+class BigQueryClient extends api.ApiClient {
+    constructor(ctx) {
+        super('https://bigquery.googleapis.com', 'bigquery/v2', ctx);
+    }
+    async getDataset(project, dataset) {
+        const name = `projects/${project}/datasets/${dataset}`;
+        const params = { datasetView: 'METADATA' };
+        return await this._get(name, params);
+    }
+    // Fetches a single table's metadata, with its location. A table or dataset
+    // that does not exist answers 404 (live, 2026-11-03). The BASIC view leaves
+    // out the storage statistics. (`selectedFields` picks schema columns, not
+    // fields: `selectedFields=tableReference` answers 400.)
+    async getTable(project, dataset, table) {
+        const name = `projects/${project}/datasets/${dataset}/tables/${table}`;
+        const params = { view: 'BASIC' };
+        return await this._get(name, params);
+    }
+    async *listTables(project, dataset) {
+        const name = `projects/${project}/datasets/${dataset}/tables`;
+        let pageToken = undefined;
+        do {
+            const params = { maxResults: 500 };
+            if (pageToken) {
+                params.pageToken = pageToken;
+            }
+            const res = await this._get(name, params);
+            if (res.status !== 200) {
+                throw new Error(`Failed to list tables: ${res.message || res.status}`);
+            }
+            const tables = res.result?.tables || [];
+            for (const table of tables) {
+                yield table;
+            }
+            pageToken = res.result?.nextPageToken;
+        } while (pageToken);
+    }
+    // Executes a SQL statement (including DDL) synchronously via jobs.query.
+    // When `location` is set it pins the job's processing location so it agrees
+    // with getQueryResults/getJob; otherwise BigQuery infers it from the
+    // referenced tables. With `dryRun` the statement is validated -- name
+    // resolution, table existence and access -- but not executed, so it serves as
+    // a cheap pre-flight probe over any reference form BigQuery can resolve.
+    //
+    // `namedParameterTypes` maps a `@name` reference to its BigQuery type code
+    // (`INT64`, `STRING`, ...) and is only useful with `dryRun`: a dry run
+    // resolves an unbound `@name` on its own, so the types are not required to
+    // make one pass -- supplying them is what makes BigQuery type-check each
+    // parameter against the column it is used with. The values sent are empty
+    // (`parameterValue: {}`, an unset value), because a dry run never evaluates
+    // them.
+    async query(project, sql, location, dryRun, namedParameterTypes) {
+        const name = `projects/${project}/queries`;
+        const body = { query: sql, useLegacySql: false };
+        if (location) {
+            body.location = location;
+        }
+        if (dryRun) {
+            body.dryRun = true;
+        }
+        const parameterNames = Object.keys(namedParameterTypes ?? {});
+        if (parameterNames.length) {
+            body.parameterMode = 'NAMED';
+            body.queryParameters = parameterNames.map(name => ({
+                name,
+                parameterType: { type: namedParameterTypes[name] },
+                parameterValue: {},
+            }));
+        }
+        return await this._post(name, body);
+    }
+    // Fetches the status/results of a running query job. Used to poll until the
+    // job reports `jobComplete`, since jobs.query can return before a slow DDL
+    // statement has finished executing.
+    async getQueryResults(project, jobId, location) {
+        const name = `projects/${project}/queries/${jobId}`;
+        const params = { maxResults: 0, timeoutMs: 10000 };
+        if (location) {
+            params.location = location;
+        }
+        return await this._get(name, params);
+    }
+    // Fetches a job's full status. status.errorResult is the definitive fatal
+    // error for a completed job; the query response's errors[] also includes
+    // non-fatal warnings, so it cannot decide success on its own.
+    async getJob(project, jobId, location) {
+        const name = `projects/${project}/jobs/${jobId}`;
+        const params = {};
+        if (location) {
+            params.location = location;
+        }
+        return await this._get(name, params);
+    }
+}
+exports.BigQueryClient = BigQueryClient;

package/build/ts/kcmd/gcp/context.d.ts

@@ -0,0 +1,10 @@
+export declare class ApiContext {
+    readonly project: string;
+    readonly location: string;
+    private _token;
+    constructor(project: string, location: string, token: string);
+    get token(): string;
+    log(message: string, data?: any): void;
+    static default(): ApiContext;
+    refresh(): void;
+}

package/build/ts/kcmd/gcp/context.js

@@ -0,0 +1,74 @@
+"use strict";
+// Context variables for GCP API requests
+//
+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.ApiContext = void 0;
+const cp = __importStar(require("child_process"));
+const GCLOUD_PROJECT_CMD = 'gcloud -q config get-value project';
+const GCLOUD_LOCATION_CMD = 'gcloud -q config get-value compute/region';
+const GCLOUD_TOKEN_CMD = 'gcloud -q auth application-default print-access-token';
+class ApiContext {
+    project;
+    location;
+    _token;
+    constructor(project, location, token) {
+        this.project = project;
+        this.location = location;
+        this._token = token;
+    }
+    get token() {
+        return this._token;
+    }
+    log(message, data) {
+        if (process.env.GCP_LOG) {
+            console.log(`[GCP_LOG] ${message}`, data ? JSON.stringify(data) : '');
+        }
+    }
+    static default() {
+        // Creates an ApiContext instance using gcloud configuration
+        const project = cp.execSync(GCLOUD_PROJECT_CMD).toString().trim();
+        const location = cp.execSync(GCLOUD_LOCATION_CMD).toString().trim();
+        const token = cp.execSync(GCLOUD_TOKEN_CMD).toString().trim();
+        if (!project || !location || !token) {
+            throw new Error('Unable to retrieve project, location, or token. Ensure gcloud is configured.');
+        }
+        return new ApiContext(project, location, token);
+    }
+    refresh() {
+        this._token = cp.execSync(GCLOUD_TOKEN_CMD).toString().trim();
+    }
+}
+exports.ApiContext = ApiContext;

package/build/ts/kcmd/gcp/crm.d.ts

@@ -0,0 +1,13 @@
+import * as api from './api';
+import * as context from './context';
+export interface Project {
+    name: string;
+    projectId: string;
+    [key: string]: any;
+}
+export declare class ResourceManagerClient extends api.ApiClient {
+    constructor(ctx: context.ApiContext);
+    getProject(project: string): Promise<api.ApiResult<Project>>;
+}
+export declare function projectNumber(project: string, ctx: context.ApiContext): Promise<string | undefined>;
+export declare function fixProject(resource: string, ctx: context.ApiContext): Promise<string>;