@meistrari/tela-cli 0.7.58 → 1.0.0

package/README.md

@@ -73,7 +73,12 @@ TELA_HOME=/tmp/tela-home node apps/tela-cli/dist/index.js env list --json
 The CLI uses the credential adapter contract from `local-config`.
 
 - `env` credentials read `TELA_ACCESS_TOKEN`, `TELA_REFRESH_TOKEN`, or `TELA_DATA_TOKEN`.
-- macOS `keychain` credentials use the system `security` command.
+- `keychain` credentials use the OS keychain: the system `security` command on
+  macOS, or the freedesktop Secret Service via `secret-tool` (libsecret) on
+  Linux. Linux needs `secret-tool` on `PATH` (Arch: `sudo pacman -S libsecret`,
+  Debian/Ubuntu: `sudo apt install libsecret-tools`) and a running Secret
+  Service such as gnome-keyring or kwallet; otherwise the adapter reports a
+  clear diagnostic instead of a token.
 - expired user-session access tokens with a refresh token are reported as
   `refreshable`, not as a hard auth failure.
 - `auth token` refreshes expired user-session access tokens when a refresh token
@@ -85,9 +90,25 @@ Default and `--json` output stay redacted.
 
 ## Tests
 
-Tests are black-box `node --test` cases that execute the compiled CLI with an
-isolated `TELA_HOME`.
+Tests are strict TypeScript black-box `node --test` cases that execute the
+compiled CLI with an isolated `TELA_HOME`. Node strips the test-only types at
+runtime; consumers do not need a TypeScript runtime.
 
 ```bash
 pnpm --filter @meistrari/tela-cli run test
 ```
+
+## Published skill installer
+
+[`scripts/install-skills.ts`](scripts/install-skills.ts) is the source for the
+postinstall skill sync. `release:prepare` bundles it deterministically with
+esbuild into `scripts/install-skills.cjs`, then copies that CJS artifact into
+the publish directory. The generated artifact is kept in the workspace so a
+fresh workspace install and an npm consumer both run plain Node through:
+
+```bash
+node scripts/install-skills.cjs --quiet
+```
+
+The published package does not require `tsx`, TypeScript, or esbuild at
+postinstall time.

package/dist/commands/auth.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAuthCommand = runAuthCommand;
+const tela_local_config_1 = require("@meistrari/tela-local-config");
+const credentials_1 = require("../credentials");
+const output_1 = require("../output");
+async function runAuthCommand(args, options, io) {
+    const [action, ...rest] = args;
+    if (!action || action === 'help' || action === '--help' || action === '-h') {
+        writeAuthHelp(io);
+        return 0;
+    }
+    if (action === 'token')
+        return await authToken(rest, options, io);
+    (0, output_1.writeError)(io, `Unknown auth command: ${action}`);
+    return 1;
+}
+async function authToken(args, options, io) {
+    const parsed = parseTokenOptions(args);
+    if ('error' in parsed) {
+        (0, output_1.writeError)(io, parsed.error);
+        return 1;
+    }
+    try {
+        const result = await resolveToken(parsed);
+        if (parsed.raw) {
+            (0, output_1.writeLine)(io, result.value);
+            return 0;
+        }
+        const payload = {
+            token: {
+                kind: parsed.kind,
+                contextId: result.resolved.id,
+                environmentId: result.resolved.context.environmentId,
+                workspaceId: result.resolved.context.workspaceId,
+                credentialProvider: result.credentialRef.provider,
+                credentialKind: result.credential.kind,
+                refreshed: result.refreshed,
+                expiresAt: result.credential.expiresAt,
+                issuedAt: result.credential.issuedAt,
+            },
+        };
+        if (options.json) {
+            (0, output_1.writeJson)(io, payload);
+            return 0;
+        }
+        (0, output_1.writeLine)(io, `${payload.token.kind} for ${payload.token.contextId}`);
+        (0, output_1.writeLine)(io, `Provider: ${payload.token.credentialProvider}`);
+        (0, output_1.writeLine)(io, `Credential: ${payload.token.credentialKind}`);
+        (0, output_1.writeLine)(io, `Refreshed: ${payload.token.refreshed ? 'yes' : 'no'}`);
+        if (payload.token.expiresAt)
+            (0, output_1.writeLine)(io, `Expires: ${payload.token.expiresAt}`);
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        (0, output_1.writeError)(io, message);
+        return 1;
+    }
+}
+async function resolveToken(options) {
+    const config = await (0, tela_local_config_1.loadConfig)();
+    const resolved = (0, tela_local_config_1.resolveContext)(config, { contextId: options.contextId });
+    const credentials = (0, credentials_1.createCliCredentialAdapter)();
+    const credentialRef = resolved.context.credentialRef;
+    const originalCredential = await credentials.get(credentialRef);
+    if (!originalCredential) {
+        throw new Error(`Missing credential for Tela context ${resolved.id}`);
+    }
+    const credential = originalCredential.kind === 'user-session'
+        ? await (0, tela_local_config_1.refreshUserSessionCredential)(resolved.environment, credentialRef, originalCredential, credentials)
+        : originalCredential;
+    const refreshed = credential !== originalCredential;
+    if (options.kind === 'access-token') {
+        if (credential.kind !== 'user-session' || !credential.accessToken) {
+            throw new Error(`Context ${resolved.id} does not have an access token credential.`);
+        }
+        return {
+            resolved,
+            credentialRef,
+            credential,
+            refreshed,
+            value: credential.accessToken,
+        };
+    }
+    if (credential.kind !== 'data-token' || !credential.dataToken) {
+        throw new Error(`Context ${resolved.id} does not have a data token credential.`);
+    }
+    return {
+        resolved,
+        credentialRef,
+        credential,
+        refreshed,
+        value: credential.dataToken,
+    };
+}
+function parseTokenOptions(args) {
+    const options = {
+        kind: 'access-token',
+        raw: false,
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--context') {
+            const value = args[index + 1];
+            if (!value)
+                return { error: 'Usage: tela auth token --context <context-id>' };
+            options.contextId = value;
+            index += 1;
+            continue;
+        }
+        if (arg === '--kind') {
+            const value = args[index + 1];
+            if (value !== 'access-token' && value !== 'data-token') {
+                return { error: 'Usage: tela auth token --kind <access-token|data-token>' };
+            }
+            options.kind = value;
+            index += 1;
+            continue;
+        }
+        if (arg === '--raw') {
+            options.raw = true;
+            continue;
+        }
+        return { error: `Unknown auth token option: ${arg}` };
+    }
+    return options;
+}
+function writeAuthHelp(io) {
+    (0, output_1.writeLine)(io, 'Usage: tela auth token [--context <context-id>] [--kind access-token|data-token] [--raw] [--json]');
+}

package/dist/commands/context.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runContextCommand = runContextCommand;
+const tela_local_config_1 = require("@meistrari/tela-local-config");
+const output_1 = require("../output");
+const credentials_1 = require("../credentials");
+async function runContextCommand(args, options, io) {
+    const [action, ...rest] = args;
+    if (!action || action === 'help' || action === '--help' || action === '-h') {
+        writeContextHelp(io);
+        return 0;
+    }
+    if (action === 'current')
+        return await currentContext(options, io);
+    if (action === 'list')
+        return await listContexts(options, io);
+    if (action === 'show')
+        return await showContext(rest[0], options, io);
+    if (action === 'use')
+        return await useContext(rest[0], options, io);
+    (0, output_1.writeError)(io, `Unknown context command: ${action}`);
+    return 1;
+}
+async function currentContext(options, io) {
+    const config = await (0, tela_local_config_1.loadConfig)();
+    const credentials = (0, credentials_1.createCliCredentialAdapter)();
+    const activeContextId = config.activeContextId;
+    const activeContext = activeContextId ? config.contexts[activeContextId] : undefined;
+    if (!activeContextId || !activeContext) {
+        if (options.json)
+            (0, output_1.writeJson)(io, { activeContext: null });
+        else
+            (0, output_1.writeLine)(io, 'No active Tela context.');
+        return 0;
+    }
+    const summary = await (0, tela_local_config_1.toContextSummary)(activeContextId, activeContext, config, credentials);
+    if (options.json) {
+        (0, output_1.writeJson)(io, { activeContext: summary });
+        return 0;
+    }
+    writeContextSummary(io, summary);
+    return 0;
+}
+async function listContexts(options, io) {
+    const config = await (0, tela_local_config_1.loadConfig)();
+    const credentials = (0, credentials_1.createCliCredentialAdapter)();
+    const publicConfig = await (0, tela_local_config_1.toPublicConfig)(config, credentials);
+    const contexts = Object.values(publicConfig.contexts);
+    if (options.json) {
+        (0, output_1.writeJson)(io, { contexts });
+        return 0;
+    }
+    if (contexts.length === 0) {
+        (0, output_1.writeLine)(io, 'No Tela contexts configured.');
+        return 0;
+    }
+    for (const context of contexts) {
+        const marker = context.isActive ? '*' : ' ';
+        const workspace = context.workspaceName ?? context.workspaceSlug ?? context.workspaceId;
+        const credential = credentialStatus(context.credential);
+        (0, output_1.writeLine)(io, `${marker} ${context.id}  ${workspace}  ${context.accountEmail ?? '-'}  credential=${credential}`);
+    }
+    return 0;
+}
+async function showContext(contextId, options, io) {
+    if (!contextId) {
+        (0, output_1.writeError)(io, 'Usage: tela context show <context-id>');
+        return 1;
+    }
+    const config = await (0, tela_local_config_1.loadConfig)();
+    const context = config.contexts[contextId];
+    if (!context) {
+        (0, output_1.writeError)(io, `Unknown Tela context: ${contextId}`);
+        return 1;
+    }
+    const summary = await (0, tela_local_config_1.toContextSummary)(contextId, context, config, (0, credentials_1.createCliCredentialAdapter)());
+    if (options.json) {
+        (0, output_1.writeJson)(io, { context: summary });
+        return 0;
+    }
+    writeContextSummary(io, summary);
+    return 0;
+}
+async function useContext(contextId, options, io) {
+    if (!contextId) {
+        (0, output_1.writeError)(io, 'Usage: tela context use <context-id>');
+        return 1;
+    }
+    const config = await (0, tela_local_config_1.updateConfig)(current => (0, tela_local_config_1.setActiveContext)(current, contextId));
+    const context = config.contexts[contextId];
+    if (!context)
+        throw new Error(`Unknown context: ${contextId}`);
+    const summary = await (0, tela_local_config_1.toContextSummary)(contextId, context, config, (0, credentials_1.createCliCredentialAdapter)());
+    if (options.json) {
+        (0, output_1.writeJson)(io, { activeContext: summary });
+        return 0;
+    }
+    (0, output_1.writeLine)(io, `Active Tela context set to ${contextId}.`);
+    return 0;
+}
+function writeContextSummary(io, context) {
+    const workspace = context.workspaceName ?? context.workspaceSlug ?? context.workspaceId;
+    const credential = credentialStatus(context.credential);
+    (0, output_1.writeLine)(io, `${context.id}`);
+    (0, output_1.writeLine)(io, `Environment: ${context.environmentLabel} (${context.environmentId})`);
+    (0, output_1.writeLine)(io, `Workspace: ${workspace} (${context.workspaceId})`);
+    (0, output_1.writeLine)(io, `Account: ${context.accountEmail ?? '-'}`);
+    (0, output_1.writeLine)(io, `Active: ${context.isActive ? 'yes' : 'no'}`);
+    (0, output_1.writeLine)(io, `Credential: ${credential}`);
+}
+function credentialStatus(context) {
+    if (context.refreshable && context.problem === 'expired')
+        return 'refreshable';
+    return context.ok ? 'valid' : context.problem ?? 'unknown';
+}
+function writeContextHelp(io) {
+    (0, output_1.writeLine)(io, 'Usage: tela context <current|list|show|use> [args] [--json]');
+}

package/dist/commands/doctor-auth.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctorCommand = runDoctorCommand;
+const tela_local_config_1 = require("@meistrari/tela-local-config");
+const credentials_1 = require("../credentials");
+const output_1 = require("../output");
+async function runDoctorCommand(args, options, io) {
+    const [action] = args;
+    if (!action || action === 'help' || action === '--help' || action === '-h') {
+        writeDoctorHelp(io);
+        return 0;
+    }
+    if (action === 'auth')
+        return await doctorAuth(options, io);
+    (0, output_1.writeError)(io, `Unknown doctor command: ${action}`);
+    return 1;
+}
+async function doctorAuth(options, io) {
+    const config = await (0, tela_local_config_1.loadConfig)();
+    const publicConfig = await (0, tela_local_config_1.toPublicConfig)(config, (0, credentials_1.createCliCredentialAdapter)());
+    const contexts = Object.values(publicConfig.contexts);
+    const ok = contexts.every(context => context.credential.ok);
+    if (options.json) {
+        (0, output_1.writeJson)(io, { ok, contexts });
+        return ok ? 0 : 2;
+    }
+    if (contexts.length === 0) {
+        (0, output_1.writeLine)(io, 'No Tela contexts configured.');
+        return 0;
+    }
+    for (const context of contexts) {
+        const status = context.credential.refreshable && context.credential.problem === 'expired'
+            ? 'refreshable'
+            : context.credential.ok ? 'ok' : context.credential.problem ?? 'failed';
+        (0, output_1.writeLine)(io, `${context.id}  credential=${status}`);
+    }
+    return ok ? 0 : 2;
+}
+function writeDoctorHelp(io) {
+    (0, output_1.writeLine)(io, 'Usage: tela doctor auth [--json]');
+}

package/dist/commands/env.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runEnvCommand = runEnvCommand;
+const tela_local_config_1 = require("@meistrari/tela-local-config");
+const credentials_1 = require("../credentials");
+const ingredients_1 = require("./ingredients");
+const output_1 = require("../output");
+async function runEnvCommand(args, options, io) {
+    const [action] = args;
+    if (!action || action === 'help' || action === '--help' || action === '-h') {
+        writeEnvHelp(io);
+        return 0;
+    }
+    const ingredientResult = await (0, ingredients_1.runIngredientEnvCommand)(args, options, io);
+    if (ingredientResult !== null)
+        return ingredientResult;
+    if (action === 'list')
+        return await listEnvironments(options, io);
+    (0, output_1.writeError)(io, `Unknown env command: ${action}`);
+    return 1;
+}
+async function listEnvironments(options, io) {
+    const config = await (0, tela_local_config_1.loadConfig)();
+    const publicConfig = await (0, tela_local_config_1.toPublicConfig)(config, (0, credentials_1.createCliCredentialAdapter)());
+    const environments = Object.values(publicConfig.environments);
+    if (options.json) {
+        (0, output_1.writeJson)(io, { environments });
+        return 0;
+    }
+    for (const environment of environments) {
+        const serviceCount = Object.keys(environment.services).length;
+        (0, output_1.writeLine)(io, `${environment.id}  ${environment.label}  ${environment.kind}  services=${serviceCount}`);
+    }
+    return 0;
+}
+function writeEnvHelp(io) {
+    (0, output_1.writeLine)(io, 'Usage: tela env list [--json]');
+    (0, output_1.writeLine)(io, 'Usage: tela env list <ingredient-slug> [-p|--pretty|--json]');
+    (0, output_1.writeLine)(io, 'Usage: tela env set <ingredient-slug> <environment>');
+}