@factorialco/fcode-cli 2.2.0 → 2.4.0

package/dist/core/types.d.ts

@@ -130,12 +130,30 @@ export interface ProcessForm {
     appRole?: AppRole;
     authMode?: FormAuthMode;
 }
+export interface ProcessUiTrigger {
+    enabled: boolean;
+    /** Identifier of the UI location the trigger is rendered in. */
+    locationId?: string;
+    /**
+     * Label shown on the trigger. May contain fcode.i18n("key") tokens, which the platform
+     * resolves when a process listing names a locale.
+     */
+    label?: string;
+    /** f0 icon name, e.g. "Globe". */
+    icon?: string;
+    /**
+     * When true the trigger executes the process synchronously and returns the result
+     * envelope; otherwise the execution is fire-and-forget.
+     */
+    awaitResult?: boolean;
+}
 export interface ProcessMetadataFields {
     name: string;
     description?: string;
     tags: string[];
     webhook?: ProcessWebhook;
     form?: ProcessForm;
+    uiTrigger?: ProcessUiTrigger;
 }
 export declare class Process extends Resource {
     id: string;
@@ -146,6 +164,7 @@ export declare class Process extends Resource {
     tags: string[];
     webhook?: ProcessWebhook;
     form?: ProcessForm;
+    uiTrigger?: ProcessUiTrigger;
     script: {
         parametersSchema: any;
         programmingLanguage: ProgrammingLanguage;
@@ -238,7 +257,14 @@ export declare class ProgrammingLanguageManifest extends Resource {
     slug: string;
     programmingLanguage: ProgrammingLanguage;
     dependencies: Array<Dependency>;
-    constructor(id: string, slug: string, programmingLanguage: ProgrammingLanguage, dependencies: Array<Dependency>);
+    inheritedDependencies: Array<Dependency>;
+    constructor(id: string, slug: string, programmingLanguage: ProgrammingLanguage, dependencies: Array<Dependency>, inheritedDependencies?: Array<Dependency>);
+    /**
+     * What an execution installs: this workspace's dependencies layered over the inherited ones, one
+     * entry per package name. Mirrors the platform's merge so a local run resolves the same install
+     * directory the cloud does.
+     */
+    get effectiveDependencies(): Array<Dependency>;
     get contentHash(): string;
 }
 export interface ErrorHandlerConfig {
@@ -273,7 +299,7 @@ export interface TeamVersionAlias {
 export interface TeamVersionFileEntry {
     tag: string;
     comment?: string;
-    createdAt: string;
+    createdAt?: string;
 }
 export interface TeamAliasFileEntry {
     name: string;
@@ -363,6 +389,7 @@ export declare const DependenciesFlags: {
 export declare class Dependency {
     name: string;
     specifier: string;
+    resolvingTeamSlug?: string;
 }
 export declare class ServiceAccount extends Resource {
     id: string;

package/dist/core/types.js

@@ -49,6 +49,7 @@ class Process extends Resource {
         this.tags = metadata.tags;
         this.webhook = metadata.webhook;
         this.form = metadata.form;
+        this.uiTrigger = metadata.uiTrigger;
         this.script = script;
         this.readme = readme;
         this.manifest = settings.dependencies.scopedToProcess && manifest !== null ? manifest : { dependencies: [] };
@@ -65,6 +66,9 @@ class Process extends Resource {
             tags: this.tags || [],
             webhook: this.webhook || null,
             form: this.form || null,
+            // Inserted only when set, so every process that predates UI triggers keeps the
+            // content hash already stored in .fcode (mirrors Team.contentHash).
+            ...(this.uiTrigger && { uiTrigger: this.uiTrigger }),
             manifestDependencies: this.manifest.dependencies,
             dependenciesScopedToProcess: this.settings.dependencies.scopedToProcess,
         });
@@ -185,12 +189,22 @@ exports.Variable = Variable;
 Variable.ENV_KEY_MAX_LENGTH = 64;
 Variable.ENV_KEY_REGEX = /^[A-Z_a-z]\w*$/;
 class ProgrammingLanguageManifest extends Resource {
-    constructor(id, slug, programmingLanguage, dependencies) {
+    constructor(id, slug, programmingLanguage, dependencies, inheritedDependencies = []) {
         super();
         this.id = id;
         this.slug = slug;
         this.programmingLanguage = programmingLanguage;
         this.dependencies = dependencies;
+        this.inheritedDependencies = inheritedDependencies;
+    }
+    /**
+     * What an execution installs: this workspace's dependencies layered over the inherited ones, one
+     * entry per package name. Mirrors the platform's merge so a local run resolves the same install
+     * directory the cloud does.
+     */
+    get effectiveDependencies() {
+        const ownNames = new Set(this.dependencies.map((dependency) => dependency.name));
+        return [...this.dependencies, ...this.inheritedDependencies.filter((dependency) => !ownNames.has(dependency.name))];
     }
     get contentHash() {
         return crypto
@@ -214,7 +228,9 @@ class Team extends Resource {
         const payload = {
             zoneId: this.zoneId || null,
             errorHandlerConfig: this.errorHandlerConfig || null,
-            parentTeamSlugs: [...(this.parentTeamSlugs || [])].sort(),
+            // Kept in the given order, not sorted: the order is the inheritance precedence, so a pure
+            // reorder is a real change that must be detected and pushed.
+            parentTeamSlugs: [...(this.parentTeamSlugs || [])],
         };
         // Inserted only when set, so every team.json that predates webhook auth keeps the
         // hash already stored in .fcode and does not report a phantom conflict. A key present
@@ -227,6 +243,18 @@ class Team extends Resource {
         if (this.primaryLocale) {
             payload.primaryLocale = this.primaryLocale;
         }
+        // Versions hash only their tags and aliases their name->tag pairs: createdAt is
+        // server-assigned and a comment is immutable once published (there is no update mutation),
+        // so neither can represent a pushable local change. Inserted only when non-empty, again to
+        // keep hashes stored before versioning existed valid.
+        if (this.versions && this.versions.length > 0) {
+            payload.versions = this.versions.map(({ tag }) => tag).sort();
+        }
+        if (this.aliases && this.aliases.length > 0) {
+            payload.aliases = this.aliases
+                .map(({ name, tag }) => ({ name, tag }))
+                .sort((a, b) => a.name.localeCompare(b.name));
+        }
         return (0, canonical_hash_1.canonicalJsonHash)(payload);
     }
 }

package/dist/core/utils/dependencies.js

@@ -12,7 +12,10 @@ async function getDependenciesPath(programmingLanguage) {
     const basePath = (0, workspace_1.baseDependenciesPath)(programmingLanguage);
     const repo = new programming_language_manifest_1.default();
     const programmingLanguageManifest = await repo.find(programmingLanguage);
-    const dependenciesDirectory = (0, env_dependencies_command_1.dependenciesHash)(programmingLanguageManifest.dependencies);
+    // The effective set, not the workspace's own: the cloud installs the inherited dependencies too,
+    // and the directory is named after the hash of what is installed. Hashing only the own list here
+    // would make a local run resolve a different directory than the platform.
+    const dependenciesDirectory = (0, env_dependencies_command_1.dependenciesHash)(programmingLanguageManifest.effectiveDependencies);
     return path.join(basePath, dependenciesDirectory);
 }
 function getProcessDependenciesPath(process) {

package/dist/env.js

@@ -14,7 +14,7 @@ const zod_1 = require("zod");
  */
 exports.envSchema = zod_1.z.object({
     // --- Cloud / auth endpoints ---
-    FCODE_CLOUD_URL: zod_1.z.string().min(1).default('https://code.factorial.dev/platform'),
+    FCODE_CLOUD_URL: zod_1.z.string().min(1).default('https://code.factorialhr.com/platform'),
     FCODE_AUTH_URL: zod_1.z.string().min(1).optional(),
     FCODE_CLIENT_ID: zod_1.z.string().min(1).default('cli'),
     // --- Local config location (defaults to os.homedir() at the call site) ---

package/dist/repositories/process.js

@@ -136,6 +136,7 @@ class ProcessRepository extends resource_1.default {
                 tags: Array.isArray(raw.tags) ? raw.tags : [],
                 webhook: raw.webhook,
                 form: raw.form,
+                uiTrigger: raw.uiTrigger,
             };
         }
         catch (error) {
@@ -156,6 +157,9 @@ class ProcessRepository extends resource_1.default {
         if (process.form !== undefined) {
             metadata.form = process.form;
         }
+        if (process.uiTrigger !== undefined) {
+            metadata.uiTrigger = process.uiTrigger;
+        }
         return metadata;
     }
     async findParameters(processSlug) {

package/dist/repositories/programming-language-manifest.d.ts

@@ -1,14 +1,30 @@
-import { ResourceMetadata, ProgrammingLanguageManifest } from '../core/types';
+import { ProgrammingLanguage, ProgrammingLanguageManifest, ResourceMetadata } from '../core/types';
 import ResourceRepositoryBase from './resource';
+/**
+ * The inherited file each language collapses its parents into. Exported so the gitignore sync names
+ * exactly what this repository writes, rather than repeating the strings.
+ */
+export declare const INHERITED_FILE_NAME: Record<ProgrammingLanguage, string>;
+export declare const DEPENDENCIES_DIR = "dependencies";
 declare class ProgrammingLanguageManifestRepository extends ResourceRepositoryBase<ProgrammingLanguageManifest> {
     constructor();
     find(slug: string): Promise<ProgrammingLanguageManifest>;
     protected getSourceCodeFileName(programmingLanguageManifest: ProgrammingLanguageManifest): string;
+    /**
+     * The inherited dependencies of one language, collapsed into a single file the way inherited
+     * variables are (`variables.inherited.env`) rather than one file per parent: two versions of the
+     * same package cannot be installed side by side, so there is only ever one winner per name and
+     * the platform has already picked it.
+     */
+    protected getInheritedFileName(programmingLanguage: ProgrammingLanguage): string;
+    getInheritedPath(programmingLanguage: ProgrammingLanguage): string;
+    private readInheritedDependencies;
     protected getResourceDirectory(programmingLanguageManifest: ProgrammingLanguageManifest): string;
     protected getResourcePath(programmingLanguageManifest: ProgrammingLanguageManifest): string;
     protected removeFiles(programmingLanguageManifest: ProgrammingLanguageManifest): Promise<void>;
     protected resourceToMetadata(programmingLanguageManifest: ProgrammingLanguageManifest): ResourceMetadata;
     protected saveFiles(programmingLanguageManifest: ProgrammingLanguageManifest): Promise<void>;
+    private removeInheritedFile;
     metadataFromFiles(slug: string): Promise<ResourceMetadata>;
     validSlug(slug: string): boolean;
     slugFormatMessage(): string;

package/dist/repositories/programming-language-manifest.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEPENDENCIES_DIR = exports.INHERITED_FILE_NAME = void 0;
 const fs = require("fs-extra");
 const path = require("node:path");
 const errors_1 = require("../core/errors");
@@ -7,6 +8,15 @@ const types_1 = require("../core/types");
 const resource_1 = require("./resource");
 const dependencies_1 = require("../core/utils/dependencies");
 const file_utils_1 = require("../utils/file-utils");
+/**
+ * The inherited file each language collapses its parents into. Exported so the gitignore sync names
+ * exactly what this repository writes, rather than repeating the strings.
+ */
+exports.INHERITED_FILE_NAME = {
+    JAVASCRIPT: 'package.inherited.json',
+    PYTHON: 'requirements.inherited.txt',
+};
+exports.DEPENDENCIES_DIR = 'dependencies';
 class ProgrammingLanguageManifestRepository extends resource_1.default {
     constructor() {
         super({
@@ -21,7 +31,7 @@ class ProgrammingLanguageManifestRepository extends resource_1.default {
         }
         const sourceCodeFileContent = fs.readFileSync(this.getResourcePath(programmingLanguageManifest));
         try {
-            return new types_1.ProgrammingLanguageManifest(programmingLanguageManifest.id, programmingLanguageManifest.slug, programmingLanguageManifest.programmingLanguage, (0, dependencies_1.dependenciesFromFile)(programmingLanguageManifest.programmingLanguage, sourceCodeFileContent.toString()));
+            return new types_1.ProgrammingLanguageManifest(programmingLanguageManifest.id, programmingLanguageManifest.slug, programmingLanguageManifest.programmingLanguage, (0, dependencies_1.dependenciesFromFile)(programmingLanguageManifest.programmingLanguage, sourceCodeFileContent.toString()), this.readInheritedDependencies(programmingLanguageManifest.programmingLanguage));
         }
         catch (error) {
             throw new errors_1.LocalProgrammingLanguageManifestNotFound(error, slug);
@@ -30,6 +40,25 @@ class ProgrammingLanguageManifestRepository extends resource_1.default {
     getSourceCodeFileName(programmingLanguageManifest) {
         return programmingLanguageManifest.programmingLanguage === 'JAVASCRIPT' ? 'package.json' : 'requirements.txt';
     }
+    /**
+     * The inherited dependencies of one language, collapsed into a single file the way inherited
+     * variables are (`variables.inherited.env`) rather than one file per parent: two versions of the
+     * same package cannot be installed side by side, so there is only ever one winner per name and
+     * the platform has already picked it.
+     */
+    getInheritedFileName(programmingLanguage) {
+        return exports.INHERITED_FILE_NAME[programmingLanguage];
+    }
+    getInheritedPath(programmingLanguage) {
+        return path.join(this._repositoryName, this.getInheritedFileName(programmingLanguage));
+    }
+    readInheritedDependencies(programmingLanguage) {
+        const inheritedPath = this.getInheritedPath(programmingLanguage);
+        if (!fs.existsSync(inheritedPath)) {
+            return [];
+        }
+        return (0, dependencies_1.dependenciesFromFile)(programmingLanguage, fs.readFileSync(inheritedPath).toString());
+    }
     getResourceDirectory(programmingLanguageManifest) {
         return this._repositoryName;
     }
@@ -40,6 +69,7 @@ class ProgrammingLanguageManifestRepository extends resource_1.default {
         await new Promise((resolve, reject) => {
             try {
                 fs.removeSync(this.getResourcePath(programmingLanguageManifest));
+                this.removeInheritedFile(programmingLanguageManifest.programmingLanguage);
                 this.removeDirectoryIfEmpty(this.getResourceDirectory(programmingLanguageManifest));
                 resolve(true);
             }
@@ -57,6 +87,26 @@ class ProgrammingLanguageManifestRepository extends resource_1.default {
     }
     async saveFiles(programmingLanguageManifest) {
         (0, file_utils_1.outputFileSyncIfChanged)(this.getResourcePath(programmingLanguageManifest), (0, dependencies_1.dependenciesToFile)(programmingLanguageManifest.programmingLanguage, programmingLanguageManifest.dependencies));
+        const { programmingLanguage, inheritedDependencies } = programmingLanguageManifest;
+        if (inheritedDependencies.length === 0) {
+            // The workspace stopped inheriting anything (a parent was removed, or emptied its manifest):
+            // a stale file would keep being installed locally and keep showing in `status`.
+            this.removeInheritedFile(programmingLanguage);
+            return;
+        }
+        // Read-only, like inherited locales and modules: these belong to a parent workspace, and
+        // editing one here would change nothing — declare the name in package.json to override it.
+        (0, file_utils_1.outputFileSyncIfChanged)(this.getInheritedPath(programmingLanguage), (0, dependencies_1.dependenciesToFile)(programmingLanguage, inheritedDependencies), {
+            readOnly: true,
+        });
+    }
+    removeInheritedFile(programmingLanguage) {
+        const inheritedPath = this.getInheritedPath(programmingLanguage);
+        if (fs.existsSync(inheritedPath)) {
+            // Written read-only, so it has to be made writable before it can go.
+            fs.chmodSync(inheritedPath, 0o644);
+            fs.removeSync(inheritedPath);
+        }
     }
     async metadataFromFiles(slug) {
         if (slug === 'JAVASCRIPT') {

package/dist/repositories/team.d.ts

@@ -17,14 +17,24 @@ export default class TeamRepository {
     /** Builds a Team from the cloud's raw settings, resolving the error-handler id to a slug. */
     fromRaw(raw: RawTeamSettings): Promise<Team>;
     /**
-     * Writes the cloud's team versions and aliases into the Team as the pull-only team.json
-     * fields (sorted for stable git diffs). These fields never enter the content hash and are
-     * stripped from pushes: all writes go through the team:versions/team:aliases commands.
+     * Writes the cloud's team versions and aliases into the Team as the team.json versioning
+     * fields (sorted for stable git diffs). Cloud entries always carry a createdAt; only
+     * hand-added local entries lack one, and those never pass through here.
      */
     applyCloudVersioning(team: Team, versions: TeamVersion[], aliases: TeamVersionAlias[]): void;
     resolveSlugToId(processSlug: string): Promise<string>;
     resolveIdToSlug(processId: string): Promise<string>;
     private parseErrorHandler;
+    /**
+     * team.json is hand-edited to declare versions, so entries without a tag are dropped and a
+     * duplicated tag keeps its first entry (a tag names one immutable snapshot).
+     */
+    private parseVersions;
+    /**
+     * An alias is a name->tag pointer; entries missing either half are dropped and a duplicated
+     * name keeps its first entry.
+     */
+    private parseAliases;
     /** A configuration without a variable key is meaningless, so it is read as absent. */
     private parseWebhookAuth;
     private toFile;

package/dist/repositories/team.js

@@ -30,12 +30,11 @@ class TeamRepository {
         catch { }
         const parentTeamSlugs = Array.isArray(raw.parentTeamSlugs) ? raw.parentTeamSlugs : [];
         const team = new types_1.Team(slug, parentTeamSlugs, raw.zoneId, this.parseErrorHandler(raw.errorHandlerConfig), this.parseWebhookAuth(raw.webhookAuth), typeof raw.primaryLocale === 'string' && raw.primaryLocale.length > 0 ? raw.primaryLocale : undefined);
-        // Parsed so a find()+save() round-trip does not drop the pull-only fields.
         if (Array.isArray(raw.versions)) {
-            team.versions = raw.versions;
+            team.versions = this.parseVersions(raw.versions);
         }
         if (Array.isArray(raw.aliases)) {
-            team.aliases = raw.aliases;
+            team.aliases = this.parseAliases(raw.aliases);
         }
         return team;
     }
@@ -54,9 +53,9 @@ class TeamRepository {
         return new types_1.Team(raw.slug, raw.parentTeamSlugs ?? [], raw.zoneId, errorHandlerConfig, this.parseWebhookAuth(raw.webhookAuth), raw.primaryLocale ?? undefined);
     }
     /**
-     * Writes the cloud's team versions and aliases into the Team as the pull-only team.json
-     * fields (sorted for stable git diffs). These fields never enter the content hash and are
-     * stripped from pushes: all writes go through the team:versions/team:aliases commands.
+     * Writes the cloud's team versions and aliases into the Team as the team.json versioning
+     * fields (sorted for stable git diffs). Cloud entries always carry a createdAt; only
+     * hand-added local entries lack one, and those never pass through here.
      */
     applyCloudVersioning(team, versions, aliases) {
         team.versions = versions
@@ -67,7 +66,7 @@ class TeamRepository {
             }
             return entry;
         })
-            .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+            .sort((a, b) => (a.createdAt ?? '').localeCompare(b.createdAt ?? ''));
         team.aliases = aliases
             .map((alias) => ({ name: alias.name, tag: alias.tag }))
             .sort((a, b) => a.name.localeCompare(b.name));
@@ -87,6 +86,50 @@ class TeamRepository {
         }
         return { processSlug: raw.processSlug, tag: raw.tag ?? null };
     }
+    /**
+     * team.json is hand-edited to declare versions, so entries without a tag are dropped and a
+     * duplicated tag keeps its first entry (a tag names one immutable snapshot).
+     */
+    parseVersions(raw) {
+        const versions = [];
+        for (const candidate of raw) {
+            if (!candidate || typeof candidate.tag !== 'string' || candidate.tag.length === 0) {
+                continue;
+            }
+            if (versions.some(({ tag }) => tag === candidate.tag)) {
+                continue;
+            }
+            const entry = { tag: candidate.tag };
+            if (typeof candidate.comment === 'string' && candidate.comment.length > 0) {
+                entry.comment = candidate.comment;
+            }
+            if (typeof candidate.createdAt === 'string' && candidate.createdAt.length > 0) {
+                entry.createdAt = candidate.createdAt;
+            }
+            versions.push(entry);
+        }
+        return versions;
+    }
+    /**
+     * An alias is a name->tag pointer; entries missing either half are dropped and a duplicated
+     * name keeps its first entry.
+     */
+    parseAliases(raw) {
+        const aliases = [];
+        for (const candidate of raw) {
+            if (!candidate || typeof candidate.name !== 'string' || candidate.name.length === 0) {
+                continue;
+            }
+            if (typeof candidate.tag !== 'string' || candidate.tag.length === 0) {
+                continue;
+            }
+            if (aliases.some(({ name }) => name === candidate.name)) {
+                continue;
+            }
+            aliases.push({ name: candidate.name, tag: candidate.tag });
+        }
+        return aliases;
+    }
     /** A configuration without a variable key is meaningless, so it is read as absent. */
     parseWebhookAuth(raw) {
         if (!raw || typeof raw.variableKey !== 'string' || raw.variableKey.length === 0) {
@@ -114,7 +157,7 @@ class TeamRepository {
         if (team.primaryLocale !== undefined) {
             file.primaryLocale = team.primaryLocale;
         }
-        // Pull-only global versioning fields, appended after the pushable settings.
+        // Global versioning fields, appended after the scalar settings.
         if (team.versions !== undefined) {
             file.versions = team.versions;
         }

package/dist/runtime/libs/python/fcode/context.py

@@ -81,22 +81,29 @@ class Processes(dict):
 class I18n:
     """Local equivalent of the cloud's fcode.i18n.
 
-    The CLI has already layered the chosen locale over the workspace's primary one, so what
-    arrives here is a single flat map. Nothing raises: a key with no translation resolves to the
-    key itself, and a placeholder with no argument is left exactly as written.
-
-    The ``options`` argument (the version a call pins in the cloud) is accepted and ignored: a
-    workspace directory holds no published snapshots, so a pinned call resolves against the files
-    on disk -- the same per-file fallback the cloud applies to a locale never published at that tag.
+    The CLI has already layered the chosen locale over the workspace's primary one, so the base
+    map that arrives here is flat. ``byLocale`` carries each locale's own files, so a call naming
+    a locale (``{"locale": "es"}``) resolves against that locale first and falls back key by key
+    to the base map, exactly like the cloud executors. Nothing raises: a key with no translation
+    resolves to the key itself, and a placeholder with no argument is left exactly as written.
+
+    The version a call pins in the cloud is accepted and ignored: a workspace directory holds no
+    published snapshots, so a pinned call resolves against the files on disk -- the same per-file
+    fallback the cloud applies to a locale never published at that tag.
     """
 
     def __init__(self, i18n_payload):
         payload = i18n_payload or {}
         self.__translations = payload.get("translations") or {}
+        self.__by_locale = payload.get("byLocale") or {}
         self.locale = payload.get("locale")
 
     def __call__(self, key, args=None, options=None):
-        template = self.__translations.get(key)
+        locale = options.get("locale") if isinstance(options, dict) else None
+        locale_map = self.__by_locale.get(str(locale)) if locale is not None else None
+        template = locale_map.get(key) if locale_map is not None else None
+        if template is None:
+            template = self.__translations.get(key)
         if template is None:
             return key
         if not isinstance(args, dict):

package/dist/services/auth-service.d.ts

@@ -8,6 +8,7 @@ declare const AuthService: {
     isAuthenticated(url: string): Promise<boolean>;
     isTokenExpiring(token: Token): boolean;
     refreshToken(authUrl: string, refreshToken: string): Promise<Token>;
+    refreshSession(url: string): Promise<boolean>;
     tryRefresh(url: string, { authUrl, token, userInfo }: AuthInfo): Promise<boolean>;
     login({ url, authUrl, email, password, clientId, clientSecret, accessToken }: Credentials): Promise<AuthInfo>;
     logout(url: string): Promise<void>;

package/dist/services/auth-service.js

@@ -117,6 +117,18 @@ const AuthService = {
         }
         throw token.error_description;
     },
+    // Force a re-mint of the access token regardless of expiry. Team groups are
+    // snapshotted into the token at issuance, so a token created before a team
+    // existed (or before the user joined it) 403s on it until re-minted (FCT-61231).
+    async refreshSession(url) {
+        try {
+            const authInfo = await this.globalConfig.getAuthInfo(url);
+            return await this.tryRefresh(url, authInfo);
+        }
+        catch {
+            return false;
+        }
+    },
     async tryRefresh(url, { authUrl, token, userInfo }) {
         if (!token.refresh_token) {
             return false;

package/dist/services/fcode-graphql-client.d.ts

@@ -10,6 +10,7 @@ declare class FcodeGraphQLClient {
     private teamSlug;
     private url;
     constructor(options: FcodeGraphQLClientOptions);
+    setAccessToken(accessToken: string): void;
     isDuplicatedError(error: any): boolean;
     isEmptyValueError(error: any): boolean;
     cleanError(error: any): any;
@@ -63,9 +64,11 @@ declare class FcodeGraphQLClient {
     /** The API upserts: an existing alias with the same name is re-pointed to the tag. */
     createTeamVersionAlias(name: string, tag: string): Promise<TeamVersionAlias>;
     deleteTeamVersionAlias(id: string): Promise<TeamVersionAlias>;
+    verifyTeamAccess(): Promise<void>;
     team(): Promise<RawTeamSettings>;
     pushTeam(update: TeamUpdateInput): Promise<RawTeamSettings>;
     mapProgrammingLanguageManifest(programmingLanguageManifest: any): ProgrammingLanguageManifest;
+    private mapDependencies;
     allProgrammingLanguageManifest(): Promise<Array<ProgrammingLanguageManifest>>;
     pushProgrammingLanguageManifest(programmingLanguageManifest: ProgrammingLanguageManifest): Promise<ProgrammingLanguageManifest>;
     allServiceAccounts(): Promise<Array<ServiceAccount>>;