chatbase 0.0.1 → 0.1.1

package/dist/commands/agents/delete.js

@@ -0,0 +1,41 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../base/base-command.js';
+import { throwIfError } from '../../client/client.js';
+import { UsageError } from '../../errors/errors.js';
+export default class AgentsDelete extends BaseCommand {
+    static description = 'Permanently delete an agent (cannot be undone)';
+    static examples = [
+        '<%= config.bin %> agents delete agt_123 --confirm agt_123'
+    ];
+    static args = {
+        agentId: Args.string({ required: true, description: 'Agent ID' })
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        confirm: Flags.string({
+            description: 'Confirm by repeating the agent ID (required in scripts and CI)'
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(AgentsDelete);
+        if (flags.confirm !== args.agentId) {
+            if (flags.confirm)
+                throw new UsageError(`--confirm value does not match ${args.agentId}.`);
+            if (!process.stdin.isTTY || flags['no-input']) {
+                throw new UsageError(`Deleting an agent is permanent. Re-run with --confirm ${args.agentId}`);
+            }
+            const { input } = await import('@inquirer/prompts');
+            const typed = await input({
+                message: `Type the agent ID (${args.agentId}) to confirm deletion:`
+            });
+            if (typed.trim() !== args.agentId)
+                throw new UsageError('Confirmation did not match; aborted.');
+        }
+        const client = this.apiClient(flags);
+        const { error, response } = await client.DELETE('/agents/{agentId}', {
+            params: { path: { agentId: args.agentId } }
+        });
+        throwIfError(response, error);
+        this.success(flags, `Deleted agent ${args.agentId}`);
+    }
+}

package/dist/commands/agents/get.js

@@ -0,0 +1,52 @@
+import { Args } from '@oclif/core';
+import { AgentCommand } from '../../base/agent-command.js';
+import { throwIfError } from '../../client/client.js';
+import { UsageError } from '../../errors/errors.js';
+export default class AgentsGet extends AgentCommand {
+    static description = 'Show one agent';
+    static examples = [
+        '<%= config.bin %> agents get agt_123',
+        '<%= config.bin %> agents get'
+    ];
+    static args = {
+        agentId: Args.string({ required: false, description: 'Agent ID' })
+    };
+    static flags = { ...AgentCommand.baseFlags };
+    async run() {
+        const { args, flags } = await this.parse(AgentsGet);
+        if (args.agentId && (flags.agent || flags['agent-name'])) {
+            throw new UsageError('Pass the agent ID either positionally or via -a/--agent-name, not both.');
+        }
+        const client = this.apiClient(flags);
+        const agentId = args.agentId ?? (await this.agentId(flags, client));
+        const { data, error, response } = await client.GET('/agents/{agentId}', {
+            params: { path: { agentId } }
+        });
+        throwIfError(response, error);
+        const a = data;
+        const str = (v) => (v == null ? '' : String(v));
+        this.printDetail(flags, data, {
+            id: str(a.id),
+            name: str(a.name),
+            model: str(a.model),
+            visibility: str(a.visibility)
+        }, [
+            { key: 'id', header: 'ID' },
+            { key: 'name', header: 'NAME' },
+            { key: 'model', header: 'MODEL' },
+            { key: 'visibility', header: 'VISIBILITY' }
+        ], [
+            ['ID', str(a.id)],
+            ['Name', str(a.name)],
+            ['Model', str(a.model)],
+            ['Visibility', str(a.visibility)],
+            ['Status', str(a.status)],
+            ['Auto-retrain', str(a.autoRetrain)],
+            ['Temperature', str(a.temp)],
+            ['Size', str(a.size)],
+            ['Created', str(a.createdAt)],
+            ['Last trained', str(a.lastTrainedAt)],
+            ['Instructions', str(a.instructions)]
+        ]);
+    }
+}

package/dist/commands/agents/list.js

@@ -0,0 +1,48 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base/base-command.js';
+import { fetchPages } from '../../client/paginate.js';
+const COLUMNS = [
+    { key: 'id', header: 'ID' },
+    { key: 'name', header: 'NAME' },
+    { key: 'model', header: 'MODEL' },
+    { key: 'visibility', header: 'VISIBILITY' }
+];
+export default class AgentsList extends BaseCommand {
+    static description = 'List all agents in the workspace';
+    static examples = [
+        '<%= config.bin %> agents list',
+        '<%= config.bin %> agents list --json'
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        limit: Flags.integer({
+            description: 'Maximum items per page',
+            min: 1,
+            max: 100
+        }),
+        cursor: Flags.string({
+            description: 'Pagination cursor from a previous page'
+        }),
+        all: Flags.boolean({ description: 'Fetch every page' })
+    };
+    async run() {
+        const { flags } = await this.parse(AgentsList);
+        const client = this.apiClient(flags);
+        const { pages, items } = await fetchPages((query) => client.GET('/agents', { params: { query } }), { limit: flags.limit, cursor: flags.cursor, all: flags.all });
+        const rows = items.map((a) => ({
+            id: String(a.id ?? ''),
+            name: String(a.name ?? ''),
+            model: String(a.model ?? ''),
+            visibility: String(a.visibility ?? '')
+        }));
+        const last = pages.at(-1);
+        // --json must stay the raw API shape even when --all merges pages
+        const raw = pages.length === 1
+            ? pages[0]
+            : { data: items, pagination: last?.pagination };
+        this.printData(flags, raw, rows, COLUMNS);
+        if (!flags.all && last?.pagination.hasMore && last.pagination.cursor) {
+            this.note(flags, `More results: rerun with --cursor ${last.pagination.cursor} (or use --all)`);
+        }
+    }
+}

package/dist/commands/agents/styles.js

@@ -0,0 +1,44 @@
+import { Args, Flags } from '@oclif/core';
+import { AgentCommand } from '../../base/agent-command.js';
+import { bodyFieldFlags } from '../../base/base-command.js';
+import { readBodyData } from '../../base/body-input.js';
+import { throwIfError } from '../../client/client.js';
+import { UsageError } from '../../errors/errors.js';
+export default class AgentsStyles extends AgentCommand {
+    static description = 'Update visual styles for an agent';
+    static examples = [
+        '<%= config.bin %> agents styles agt_123 --data \'{"chat":{"theme":"dark"}}\'',
+        '<%= config.bin %> agents styles --data @styles.json'
+    ];
+    static args = {
+        agentId: Args.string({
+            required: false,
+            description: 'Agent ID'
+        })
+    };
+    static flags = {
+        ...AgentCommand.baseFlags,
+        ...bodyFieldFlags,
+        data: Flags.string({
+            required: true,
+            description: 'JSON body (@file, @-, or inline). See API docs for style properties'
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(AgentsStyles);
+        if (args.agentId && (flags.agent || flags['agent-name'])) {
+            throw new UsageError('Pass the agent ID either positionally or via -a/--agent-name, not both.');
+        }
+        const stylesData = await readBodyData(flags.data, flags.field);
+        const client = this.apiClient(flags);
+        const agentId = args.agentId ?? (await this.agentId(flags, client));
+        const { error, response } = await client.PUT('/agents/{agentId}/styles', {
+            params: { path: { agentId } },
+            body: {
+                styles: stylesData
+            }
+        });
+        throwIfError(response, error);
+        this.success(flags, `Updated styles for ${agentId}`);
+    }
+}

package/dist/commands/agents/train.js

@@ -0,0 +1,31 @@
+import { Args } from '@oclif/core';
+import { AgentCommand } from '../../base/agent-command.js';
+import { throwIfError } from '../../client/client.js';
+import { UsageError } from '../../errors/errors.js';
+export default class AgentsTrain extends AgentCommand {
+    static description = 'Queue a training job for an agent';
+    static examples = [
+        '<%= config.bin %> agents train agt_123',
+        '<%= config.bin %> agents train'
+    ];
+    static args = {
+        agentId: Args.string({
+            required: false,
+            description: 'Agent ID to train (defaults to the configured agent, like other commands)'
+        })
+    };
+    static flags = { ...AgentCommand.baseFlags };
+    async run() {
+        const { args, flags } = await this.parse(AgentsTrain);
+        if (args.agentId && (flags.agent || flags['agent-name'])) {
+            throw new UsageError('Pass the agent ID either positionally or via -a/--agent-name, not both.');
+        }
+        const client = this.apiClient(flags);
+        const agentId = args.agentId ?? (await this.agentId(flags, client));
+        const { error, response } = await client.POST('/agents/{agentId}/train', {
+            params: { path: { agentId } }
+        });
+        throwIfError(response, error);
+        this.success(flags, `Training started for ${agentId}`);
+    }
+}

package/dist/commands/agents/update.js

@@ -0,0 +1,47 @@
+import { Args, Flags } from '@oclif/core';
+import { AgentCommand } from '../../base/agent-command.js';
+import { bodyFieldFlags } from '../../base/base-command.js';
+import { readBodyData } from '../../base/body-input.js';
+import { throwIfError } from '../../client/client.js';
+import { UsageError } from '../../errors/errors.js';
+export default class AgentsUpdate extends AgentCommand {
+    static description = 'Update an existing agent';
+    static examples = [
+        '<%= config.bin %> agents update agt_123 --name "New Name"',
+        '<%= config.bin %> agents update --name "New Name"',
+        '<%= config.bin %> agents update agt_123 --data @agent.json'
+    ];
+    static args = {
+        agentId: Args.string({ required: false, description: 'Agent ID' })
+    };
+    static flags = {
+        ...AgentCommand.baseFlags,
+        ...bodyFieldFlags,
+        name: Flags.string({ description: 'Agent name' }),
+        instructions: Flags.string({ description: 'System instructions' }),
+        model: Flags.string({ description: 'Model ID' }),
+        data: Flags.string({
+            description: 'JSON body (@file, @-, or inline). Fields: name, instructions, model, visibility, temp'
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(AgentsUpdate);
+        if (args.agentId && (flags.agent || flags['agent-name'])) {
+            throw new UsageError('Pass the agent ID either positionally or via -a/--agent-name, not both.');
+        }
+        const body = {
+            ...(await readBodyData(flags.data, flags.field)),
+            ...(flags.name ? { name: flags.name } : {}),
+            ...(flags.instructions ? { instructions: flags.instructions } : {}),
+            ...(flags.model ? { model: flags.model } : {})
+        };
+        const client = this.apiClient(flags);
+        const agentId = args.agentId ?? (await this.agentId(flags, client));
+        const { error, response } = await client.PUT('/agents/{agentId}', {
+            params: { path: { agentId } },
+            body: body
+        });
+        throwIfError(response, error);
+        this.success(flags, `Updated agent ${agentId}`);
+    }
+}

package/dist/commands/api.js

@@ -0,0 +1,69 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand, bodyFieldFlags } from '../base/base-command.js';
+import { parseFields, readBodyData } from '../base/body-input.js';
+import { rawApiFetch } from '../client/client.js';
+import { resolveApiKey } from '../config/resolve.js';
+import { parseErrorResponse, UsageError } from '../errors/errors.js';
+/** k=v -> [k, v], splitting only on the first '=' so values containing '='
+ * (base64, JSON snippets, etc.) survive intact. */
+function parseField(field) {
+    const idx = field.indexOf('=');
+    if (idx === -1) {
+        throw new UsageError(`--field must be key=value (got "${field}")`);
+    }
+    return [field.slice(0, idx), field.slice(idx + 1)];
+}
+export default class Api extends BaseCommand {
+    static description = 'Call the Chatbase API directly — an escape hatch for endpoints without a dedicated command';
+    static examples = [
+        '<%= config.bin %> api GET /agents',
+        '<%= config.bin %> api GET /agents --field limit=5',
+        '<%= config.bin %> api POST /agents --body \'{"name":"Support Bot"}\'',
+        '<%= config.bin %> api PATCH /agents/agt_123 --body @patch.json'
+    ];
+    static args = {
+        method: Args.string({
+            required: true,
+            options: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
+            description: 'HTTP method'
+        }),
+        path: Args.string({
+            required: true,
+            description: 'API path relative to /api/v2, e.g. /agents'
+        })
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        ...bodyFieldFlags,
+        query: Flags.string({
+            multiple: true,
+            description: 'Query param k=v (repeatable)'
+        }),
+        body: Flags.string({
+            description: 'JSON request body (@file, @-, or inline JSON)'
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(Api);
+        const resolved = resolveApiKey();
+        if (!resolved) {
+            throw new UsageError('Not authenticated. Run `chatbase auth login`, or set CHATBASE_API_KEY.');
+        }
+        const query = (flags.query ?? []).map(parseField);
+        const bodyData = flags.body
+            ? await readBodyData(flags.body, flags.field)
+            : parseFields(flags.field);
+        const hasBody = Object.keys(bodyData).length > 0;
+        const res = await rawApiFetch(args.method, args.path, {
+            apiKey: resolved.value,
+            query,
+            body: hasBody ? bodyData : undefined
+        });
+        if (res.status >= 400) {
+            throw parseErrorResponse(res.status, res.body, res.requestId);
+        }
+        // The escape hatch IS raw by design — always the exact response JSON,
+        // regardless of --json/--plain/pretty.
+        process.stdout.write(`${JSON.stringify(res.body, null, 2)}\n`);
+    }
+}

package/dist/commands/auth/login.js

@@ -0,0 +1,128 @@
+import { spawn } from 'node:child_process';
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base/base-command.js';
+import { readStdinToEnd } from '../../base/body-input.js';
+import { rawApiFetch } from '../../client/client.js';
+import { pairingBaseUrl, pollExchange, startPairing } from '../../client/pairing.js';
+import { configFile } from '../../config/paths.js';
+import { writeUserConfig } from '../../config/store.js';
+import { parseErrorResponse, UsageError } from '../../errors/errors.js';
+function tryOpenBrowser(url) {
+    try {
+        if (process.platform === 'win32') {
+            spawn('cmd', ['/c', 'start', '', url], {
+                detached: true,
+                stdio: 'ignore'
+            })
+                .on('error', () => { })
+                .unref();
+            return;
+        }
+        const cmd = process.platform === 'darwin' ? 'open' : 'xdg-open';
+        spawn(cmd, [url], { detached: true, stdio: 'ignore' })
+            .on('error', () => { })
+            .unref();
+    }
+    catch {
+        // Synchronous spawn() failure — same best-effort contract.
+    }
+}
+export default class AuthLogin extends BaseCommand {
+    static description = 'Authenticate with Chatbase — paste an API key or log in via browser';
+    static examples = [
+        '<%= config.bin %> auth login',
+        '<%= config.bin %> auth login --browser',
+        'cat key.txt | <%= config.bin %> auth login --with-token'
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        'with-token': Flags.boolean({
+            description: 'Read the API key from stdin'
+        }),
+        browser: Flags.boolean({
+            description: 'Log in via browser — approve a code at chatbase.co/activate'
+        })
+    };
+    requireAuth = false;
+    async run() {
+        const { flags } = await this.parse(AuthLogin);
+        if (flags['with-token']) {
+            if (process.stdin.isTTY)
+                throw new UsageError('--with-token reads the key from stdin. Pipe it: chatbase auth login --with-token < key.txt');
+            const key = (await readStdinToEnd()).trim();
+            if (!key)
+                throw new UsageError('No token received on stdin.');
+            return this.verifyAndStore(flags, key);
+        }
+        if (flags.browser) {
+            return this.browserLogin(flags);
+        }
+        if (process.stdin.isTTY && !flags['no-input']) {
+            const { select } = await import('@inquirer/prompts');
+            const method = await select({
+                message: 'How do you want to authenticate?',
+                choices: [
+                    {
+                        value: 'browser',
+                        name: 'Log in with browser (recommended)'
+                    },
+                    { value: 'paste', name: 'Paste an API key' }
+                ]
+            });
+            if (method === 'browser') {
+                return this.browserLogin(flags);
+            }
+            const { password } = await import('@inquirer/prompts');
+            const key = (await password({ message: 'Key:', mask: '●' })).trim();
+            if (!key)
+                throw new UsageError('No key entered.');
+            return this.verifyAndStore(flags, key);
+        }
+        throw new UsageError('Cannot prompt (no TTY or --no-input). Use: chatbase auth login --with-token < key.txt');
+    }
+    async browserLogin(flags) {
+        const pairing = await startPairing();
+        this.note(flags, `\nYour code: ${this.palette(flags).green(pairing.userCode)}\n`);
+        this.note(flags, `Open ${pairing.verificationUri} and enter the code to approve.`);
+        if (process.stdout.isTTY && !flags['no-input']) {
+            tryOpenBrowser(pairing.verificationUri);
+            this.note(flags, 'Waiting for approval...');
+        }
+        const result = await pollExchange(pairing.deviceCode, {
+            intervalMs: pairing.interval * 1000,
+            timeoutMs: pairing.expiresIn * 1000,
+            onPoll: () => {
+                if (!flags.quiet) {
+                    process.stderr.write('.');
+                }
+            }
+        });
+        if (!flags.quiet)
+            process.stderr.write('\n');
+        writeUserConfig({
+            apiKey: result.apiKey,
+            apiKeySource: 'pairing'
+        });
+        this.success(flags, `Logged in to workspace ${result.workspace.name}`);
+        this.note(flags, `Saved to ${configFile()}`);
+    }
+    async verifyAndStore(flags, key) {
+        const res = await rawApiFetch('GET', '/api/cli-pairing/me', {
+            apiKey: key,
+            baseUrl: pairingBaseUrl()
+        });
+        if (res.status === 200) {
+            const body = res.body;
+            writeUserConfig({ apiKey: key });
+            this.success(flags, `Logged in${body.workspace?.name ? ` to workspace ${body.workspace.name}` : ''}`);
+        }
+        else if (res.status === 404) {
+            writeUserConfig({ apiKey: key });
+            this.note(flags, 'Key stored (verification unavailable — it will be checked on first use).');
+        }
+        else {
+            throw parseErrorResponse(res.status, res.body, res.requestId);
+        }
+        this.note(flags, `Saved to ${configFile()}`);
+    }
+}

package/dist/commands/auth/logout.js

@@ -0,0 +1,40 @@
+import fs from 'node:fs';
+import { BaseCommand } from '../../base/base-command.js';
+import { rawApiFetch } from '../../client/client.js';
+import { pairingBaseUrl } from '../../client/pairing.js';
+import { configFile } from '../../config/paths.js';
+import { readUserConfig } from '../../config/store.js';
+export default class AuthLogout extends BaseCommand {
+    static description = 'Remove the stored API key (revokes CLI-paired keys server-side)';
+    static examples = ['<%= config.bin %> auth logout'];
+    static flags = { ...BaseCommand.baseFlags };
+    requireAuth = false;
+    async run() {
+        const { flags } = await this.parse(AuthLogout);
+        const config = readUserConfig();
+        if (!config.apiKey) {
+            this.note(flags, 'No stored credential — nothing to remove.');
+            return;
+        }
+        if (config.apiKeySource === 'pairing') {
+            try {
+                const res = await rawApiFetch('DELETE', '/api/cli-pairing/me', {
+                    apiKey: config.apiKey,
+                    baseUrl: pairingBaseUrl()
+                });
+                if (res.status >= 200 && res.status < 300) {
+                    this.note(flags, 'CLI session revoked server-side.');
+                }
+                else {
+                    this.note(flags, this.palette(flags).yellow(`! Could not revoke the key server-side (${res.status}) — revoke it manually at chatbase.co if needed.`));
+                }
+            }
+            catch (err) {
+                const detail = err instanceof Error ? err.message : String(err);
+                this.note(flags, this.palette(flags).yellow(`! Could not reach the API to revoke the key (${detail}) — revoke it manually at chatbase.co if needed.`));
+            }
+        }
+        fs.rmSync(configFile(), { force: true });
+        this.success(flags, 'Logged out (stored config removed).');
+    }
+}

package/dist/commands/auth/status.js

@@ -0,0 +1,88 @@
+import { BaseCommand } from '../../base/base-command.js';
+import { DEFAULT_BASE_URL, rawApiFetch, resolveBaseUrl } from '../../client/client.js';
+import { pairingBaseUrl } from '../../client/pairing.js';
+import { resolveApiKey } from '../../config/resolve.js';
+export default class AuthStatus extends BaseCommand {
+    static description = 'Show the active credential and where it comes from';
+    static examples = ['<%= config.bin %> auth status'];
+    static flags = { ...BaseCommand.baseFlags };
+    requireAuth = false;
+    async run() {
+        const { flags } = await this.parse(AuthStatus);
+        this.warnIfBaseUrlOverridden(flags);
+        const resolved = resolveApiKey();
+        if (!resolved) {
+            this.note(flags, 'Not authenticated. Run `chatbase auth login`.');
+            // Exit 1 so scripts can use `auth status` as an auth probe
+            // (same contract as `gh auth status`).
+            this.exit(1);
+        }
+        const tail = resolved.value.length > 8 ? `…${resolved.value.slice(-4)}` : '…****';
+        this.note(flags, `Credential: ${tail} (from ${resolved.source})`);
+        const res = await rawApiFetch('GET', '/api/cli-pairing/me', {
+            apiKey: resolved.value,
+            baseUrl: pairingBaseUrl()
+        });
+        if (res.status === 200) {
+            this.renderMe(flags, res.body);
+        }
+        else if (res.status === 401 || res.status === 403) {
+            this.renderAuthError(flags, res.body);
+        }
+        else {
+            this.note(flags, this.palette(flags).yellow(`! Could not verify key (server returned ${res.status})`));
+        }
+    }
+    warnIfBaseUrlOverridden(flags) {
+        const baseUrl = resolveBaseUrl();
+        if (baseUrl === DEFAULT_BASE_URL)
+            return;
+        this.note(flags, this.palette(flags).yellow(`! API base overridden: ${baseUrl} (CHATBASE_API_URL)`));
+    }
+    renderMe(flags, body) {
+        this.note(flags, `Workspace: ${body.workspace?.name ?? 'unknown'} (plan: ${body.plan ?? 'unknown'})`);
+        const cred = body.credential;
+        if (cred?.source === 'cli') {
+            this.note(flags, 'Key type: CLI-paired device');
+        }
+        if (cred?.expiresAt) {
+            this.renderExpiry(flags, cred.expiresAt);
+        }
+        if (cred?.permissions) {
+            this.note(flags, `Scopes: ${cred.permissions.join(', ') || 'none'}`);
+        }
+        else if (cred?.permissions === null) {
+            this.note(flags, 'Scopes: full access');
+        }
+    }
+    renderExpiry(flags, expiresAt) {
+        const remaining = Math.ceil((new Date(expiresAt).getTime() - Date.now()) / (1000 * 60 * 60 * 24));
+        if (Number.isNaN(remaining)) {
+            this.note(flags, this.palette(flags).yellow(`! Could not parse credential expiry (${expiresAt})`));
+        }
+        else if (remaining <= 0) {
+            this.note(flags, this.palette(flags).yellow('! Already expired — re-pair with `chatbase auth login --browser`'));
+        }
+        else if (remaining <= 7) {
+            this.note(flags, this.palette(flags).yellow(`! Expires in ${remaining} day${remaining !== 1 ? 's' : ''} — re-pair with \`chatbase auth login --browser\``));
+        }
+        else {
+            this.note(flags, `Expires in ${remaining} day${remaining !== 1 ? 's' : ''}`);
+        }
+    }
+    renderAuthError(flags, errBody) {
+        const code = errBody?.error?.code;
+        if (code === 'AUTH_EXPIRED_API_KEY') {
+            this.note(flags, this.palette(flags).yellow('! Key has expired — re-pair with `chatbase auth login --browser`'));
+        }
+        else if (code === 'SUBSCRIPTION_API_RESTRICTED_PLAN') {
+            // /me is scope-exempt server-side (any valid key may introspect
+            // itself), so the only 403 it returns is the plan restriction —
+            // pointing at key scopes here would send users the wrong way.
+            this.note(flags, this.palette(flags).yellow("! This workspace's plan does not include API access — a Standard plan or higher is required."));
+        }
+        else {
+            this.note(flags, this.palette(flags).yellow('! Key appears invalid or lacks API access.'));
+        }
+    }
+}