@posterly/cli 0.1.2 → 0.1.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +26 -5
- package/bin/posterly.mjs +595 -24
- package/generated/platform-manifest.mjs +2 -1
- package/package.json +4 -1
package/README.md
CHANGED
|
@@ -8,6 +8,7 @@ Run the CLI without installing anything globally:
|
|
|
8
8
|
|
|
9
9
|
```bash
|
|
10
10
|
npx @posterly/cli@latest auth:login
|
|
11
|
+
npx @posterly/cli@latest doctor --pretty
|
|
11
12
|
npx @posterly/cli@latest whoami --pretty
|
|
12
13
|
```
|
|
13
14
|
|
|
@@ -20,6 +21,7 @@ Optional global install:
|
|
|
20
21
|
```bash
|
|
21
22
|
npm i -g @posterly/cli@latest
|
|
22
23
|
posterly auth:login
|
|
24
|
+
posterly doctor --pretty
|
|
23
25
|
posterly whoami --pretty
|
|
24
26
|
```
|
|
25
27
|
|
|
@@ -35,7 +37,8 @@ folder. In that case `posterly` will only be available as
|
|
|
35
37
|
|
|
36
38
|
```bash
|
|
37
39
|
posterly auth:login
|
|
38
|
-
posterly auth:key
|
|
40
|
+
posterly auth:key
|
|
41
|
+
posterly doctor --pretty
|
|
39
42
|
posterly whoami --pretty
|
|
40
43
|
posterly accounts:list --pretty
|
|
41
44
|
posterly accounts:disconnect 123 --confirm --pretty
|
|
@@ -49,10 +52,15 @@ posterly posts:create --account-id 123 --caption "Launching soon" --scheduled-at
|
|
|
49
52
|
posterly posts:status 123 --status paused --confirm --pretty
|
|
50
53
|
posterly posts:missing 123 --pretty
|
|
51
54
|
posterly posts:release-id 123 --release-id launch-2026-05-16 --group-id campaign-42 --pretty
|
|
55
|
+
posterly posts:delete 123 --confirm --pretty
|
|
52
56
|
posterly posts:delete-group campaign-42 --confirm --pretty
|
|
57
|
+
posterly webhooks:delete wh_123 --confirm --pretty
|
|
53
58
|
posterly gbp:reviews --account-id 123 --unanswered --pretty
|
|
54
59
|
posterly gbp:review-link 123 --pretty
|
|
55
60
|
posterly gbp:audit 123 --pretty
|
|
61
|
+
posterly gbp:media --account-id 123 --pretty
|
|
62
|
+
posterly gbp:add-media --account-id 123 --source-url https://cdn.example.com/front.jpg --category COVER --confirm --pretty
|
|
63
|
+
posterly gbp:delete-media --account-id 123 --media-name accounts/123/locations/456/media/abc --confirm --pretty
|
|
56
64
|
posterly gbp:suggest-reply --account-id 123 --star-rating 5 --review-text "Great service" --pretty
|
|
57
65
|
posterly gbp:reply --account-id 123 --review-name accounts/123/locations/456/reviews/abc --comment "Thanks Alex. Glad we could help." --confirm --pretty
|
|
58
66
|
```
|
|
@@ -61,10 +69,23 @@ The CLI outputs JSON by default so it can be piped into `jq` or other tools. Use
|
|
|
61
69
|
`--pretty` for formatted output. `--human` is accepted as an alias for
|
|
62
70
|
`--pretty` for older examples.
|
|
63
71
|
|
|
64
|
-
|
|
72
|
+
Use `posterly doctor --pretty` to check Node version, the configured API origin,
|
|
73
|
+
whether an API key is present, whether the key works against `/api/v1/whoami`,
|
|
74
|
+
and whether a newer `@posterly/cli` package is published. Add `--no-npm` to skip
|
|
75
|
+
the npm registry check in locked-down environments.
|
|
65
76
|
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
77
|
+
Authentication:
|
|
78
|
+
|
|
79
|
+
- Prefer `posterly auth:login` for browser-based OAuth.
|
|
80
|
+
- Use `posterly auth:key` with no argument to paste an API key into a hidden prompt.
|
|
81
|
+
- For non-interactive setup, pipe the key on stdin: `printf '%s\n' "$POSTERLY_API_KEY" | posterly auth:key`.
|
|
82
|
+
- `POSTERLY_API_KEY` can be used directly without saving local config.
|
|
83
|
+
|
|
84
|
+
`--api-key` is still supported for automation, but avoid passing live keys as
|
|
85
|
+
command-line arguments in interactive shells because argv can be stored in shell
|
|
86
|
+
history or exposed through local process listings.
|
|
69
87
|
|
|
70
88
|
Set `--url` or `POSTERLY_URL` to point at a non-production posterly deployment.
|
|
89
|
+
The CLI refuses to send API keys to non-local `http://` URLs by default. Use
|
|
90
|
+
`https://`, `http://localhost` for local development, or `--allow-insecure-url`
|
|
91
|
+
only for a trusted private development endpoint.
|
package/bin/posterly.mjs
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
#!/usr/bin/env node
|
|
2
2
|
|
|
3
|
-
import { readFile, mkdir, writeFile, rm } from 'node:fs/promises';
|
|
3
|
+
import { readFile, mkdir, writeFile, rm, chmod, rename } from 'node:fs/promises';
|
|
4
4
|
import { existsSync } from 'node:fs';
|
|
5
5
|
import os from 'node:os';
|
|
6
6
|
import path from 'node:path';
|
|
@@ -15,16 +15,37 @@ import {
|
|
|
15
15
|
const DEFAULT_BASE_URL = 'https://www.poster.ly';
|
|
16
16
|
const CONFIG_DIR = path.join(os.homedir(), '.posterly');
|
|
17
17
|
const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
|
|
18
|
+
const CLI_PACKAGE_NAME = '@posterly/cli';
|
|
19
|
+
const CLI_NPM_LATEST_URL = 'https://registry.npmjs.org/@posterly%2fcli/latest';
|
|
20
|
+
const REQUEST_TIMEOUT_MS = 2500;
|
|
21
|
+
const REQUIRED_NODE_MAJOR = 20;
|
|
18
22
|
const OAUTH_CLIENT_ID = 'posterly-cli';
|
|
19
23
|
const OAUTH_CALLBACK_PORT = 37373;
|
|
20
24
|
const OAUTH_CALLBACK_PATH = '/oauth/callback';
|
|
21
25
|
const OAUTH_SCOPES = ['accounts:read', 'accounts:write', 'posts:read', 'posts:write', 'media:write', 'analytics:read'];
|
|
26
|
+
const TRUSTED_POSTERLY_HOSTS = new Set(['poster.ly', 'www.poster.ly']);
|
|
27
|
+
const GOOGLE_BUSINESS_MEDIA_CATEGORIES = [
|
|
28
|
+
'COVER',
|
|
29
|
+
'PROFILE',
|
|
30
|
+
'LOGO',
|
|
31
|
+
'EXTERIOR',
|
|
32
|
+
'INTERIOR',
|
|
33
|
+
'PRODUCT',
|
|
34
|
+
'AT_WORK',
|
|
35
|
+
'FOOD_AND_DRINK',
|
|
36
|
+
'MENU',
|
|
37
|
+
'COMMON_AREA',
|
|
38
|
+
'ROOMS',
|
|
39
|
+
'TEAMS',
|
|
40
|
+
'ADDITIONAL',
|
|
41
|
+
];
|
|
22
42
|
|
|
23
43
|
const COMMANDS = [
|
|
24
44
|
'auth:login [--url https://www.poster.ly] [--no-open]',
|
|
25
|
-
'auth:key [
|
|
45
|
+
'auth:key [--url https://www.poster.ly]',
|
|
26
46
|
'auth:status',
|
|
27
47
|
'auth:logout',
|
|
48
|
+
'doctor [--url https://www.poster.ly] [--no-npm]',
|
|
28
49
|
'whoami',
|
|
29
50
|
'accounts:list|disconnect [--workspace-id id]',
|
|
30
51
|
'connect:link [platform] [--workspace-id id] [--include-planned]',
|
|
@@ -35,7 +56,7 @@ const COMMANDS = [
|
|
|
35
56
|
'slots:next',
|
|
36
57
|
'media:upload|signed-upload|upload-from-url',
|
|
37
58
|
'analytics:account|posts',
|
|
38
|
-
'gbp:reviews|review-link|audit|suggest-reply|reply|delete-reply',
|
|
59
|
+
'gbp:reviews|review-link|audit|media|add-media|delete-media|suggest-reply|reply|delete-reply',
|
|
39
60
|
'ai:video-options|video-function|generate-video|video-jobs|video-job',
|
|
40
61
|
'activity:list',
|
|
41
62
|
'notifications:list',
|
|
@@ -55,7 +76,7 @@ async function main() {
|
|
|
55
76
|
posterly: 'CLI for the posterly API',
|
|
56
77
|
usage: 'posterly <command> [--flag value]',
|
|
57
78
|
commands: COMMANDS,
|
|
58
|
-
auth: 'Run `npx @posterly/cli@latest auth:login` for the no-install flow, `posterly auth:login` after global install, `posterly auth:key
|
|
79
|
+
auth: 'Run `npx @posterly/cli@latest auth:login` for the no-install flow, `posterly auth:login` after global install, run `posterly auth:key` and paste a key at the prompt, or set POSTERLY_API_KEY.',
|
|
59
80
|
}, flags);
|
|
60
81
|
}
|
|
61
82
|
|
|
@@ -63,6 +84,7 @@ async function main() {
|
|
|
63
84
|
if (command === 'auth:key') return saveKey(positional[0], flags);
|
|
64
85
|
if (command === 'auth:status') return authStatus(flags);
|
|
65
86
|
if (command === 'auth:logout') return logout(flags);
|
|
87
|
+
if (command === 'doctor') return doctor(flags);
|
|
66
88
|
|
|
67
89
|
const client = await createClient(flags);
|
|
68
90
|
|
|
@@ -165,6 +187,9 @@ async function main() {
|
|
|
165
187
|
group_id: flags.groupId,
|
|
166
188
|
})), flags);
|
|
167
189
|
case 'posts:delete':
|
|
190
|
+
if (!flagEnabled(flags.confirm)) {
|
|
191
|
+
throw new Error('Deleting a post is irreversible. Re-run with --confirm after verifying the post ID.');
|
|
192
|
+
}
|
|
168
193
|
return print(await client.delete(`/posts/${required(positional[0] || flags.id, 'post id')}`), flags);
|
|
169
194
|
case 'posts:delete-group':
|
|
170
195
|
if (!flagEnabled(flags.confirm)) {
|
|
@@ -236,6 +261,34 @@ async function main() {
|
|
|
236
261
|
account_id: flags.accountId || positional[0],
|
|
237
262
|
location_id: flags.locationId,
|
|
238
263
|
})), flags);
|
|
264
|
+
case 'gbp:media':
|
|
265
|
+
return print(await client.get(withQuery('/google-business/media', {
|
|
266
|
+
workspace_id: flags.workspaceId,
|
|
267
|
+
account_id: flags.accountId || positional[0],
|
|
268
|
+
location_id: flags.locationId,
|
|
269
|
+
})), flags);
|
|
270
|
+
case 'gbp:add-media':
|
|
271
|
+
if (!flagEnabled(flags.confirm)) {
|
|
272
|
+
throw new Error('Adding Google Business profile media changes the public listing. Re-run with --confirm after verifying the location, category, and media URL.');
|
|
273
|
+
}
|
|
274
|
+
return print(await client.post('/google-business/media', clean({
|
|
275
|
+
workspace_id: flags.workspaceId,
|
|
276
|
+
account_id: flags.accountId,
|
|
277
|
+
location_id: flags.locationId,
|
|
278
|
+
source_url: required(flags.sourceUrl || positional[0], '--source-url'),
|
|
279
|
+
category: validateGoogleBusinessMediaCategory(required(flags.category || positional[1], '--category')),
|
|
280
|
+
media_format: flags.mediaFormat ? validateGoogleBusinessMediaFormat(flags.mediaFormat) : undefined,
|
|
281
|
+
})), flags);
|
|
282
|
+
case 'gbp:delete-media':
|
|
283
|
+
if (!flagEnabled(flags.confirm)) {
|
|
284
|
+
throw new Error('Deleting Google Business profile media is irreversible. Re-run with --confirm after verifying the media resource name.');
|
|
285
|
+
}
|
|
286
|
+
return print(await client.delete('/google-business/media', clean({
|
|
287
|
+
workspace_id: flags.workspaceId,
|
|
288
|
+
account_id: flags.accountId,
|
|
289
|
+
location_id: flags.locationId,
|
|
290
|
+
media_name: required(flags.mediaName || positional[0], '--media-name'),
|
|
291
|
+
})), flags);
|
|
239
292
|
case 'gbp:suggest-reply':
|
|
240
293
|
return print(await client.post('/google-business/reviews/suggest-reply', clean({
|
|
241
294
|
workspace_id: flags.workspaceId,
|
|
@@ -322,6 +375,9 @@ async function main() {
|
|
|
322
375
|
is_active: flags.active === undefined ? undefined : booleanFlag(flags.active),
|
|
323
376
|
})), flags);
|
|
324
377
|
case 'webhooks:delete':
|
|
378
|
+
if (!flagEnabled(flags.confirm)) {
|
|
379
|
+
throw new Error('Deleting a webhook is irreversible. Re-run with --confirm after verifying the webhook ID.');
|
|
380
|
+
}
|
|
325
381
|
return print(await client.delete(`/webhooks/${required(positional[0] || flags.id, 'webhook id')}`), flags);
|
|
326
382
|
case 'webhooks:test':
|
|
327
383
|
return print(await client.post(`/webhooks/${required(positional[0] || flags.id, 'webhook id')}/test`, {}), flags);
|
|
@@ -366,10 +422,11 @@ function parseArgs(args) {
|
|
|
366
422
|
}
|
|
367
423
|
|
|
368
424
|
async function createClient(flags) {
|
|
369
|
-
const
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
425
|
+
const { apiKey, baseUrl } = await resolveAuthContext(flags);
|
|
426
|
+
if (!apiKey) {
|
|
427
|
+
throw new Error('Missing API key. Run `npx @posterly/cli@latest auth:login`, `posterly auth:login` after global install, run `posterly auth:key` and paste a key at the prompt, or set POSTERLY_API_KEY.');
|
|
428
|
+
}
|
|
429
|
+
validateBaseUrlForKeyUse(baseUrl, flags, 'send an API key to');
|
|
373
430
|
|
|
374
431
|
async function request(method, path, body) {
|
|
375
432
|
const res = await fetch(`${baseUrl}/api/v1${path}`, {
|
|
@@ -402,21 +459,108 @@ async function createClient(flags) {
|
|
|
402
459
|
};
|
|
403
460
|
}
|
|
404
461
|
|
|
462
|
+
async function resolveAuthContext(flags = {}) {
|
|
463
|
+
const config = await readConfig();
|
|
464
|
+
const apiKey = flags.apiKey || process.env.POSTERLY_API_KEY || config.apiKey || '';
|
|
465
|
+
const baseUrl = normalizeBaseUrl(flags.url || process.env.POSTERLY_URL || config.baseUrl || DEFAULT_BASE_URL);
|
|
466
|
+
const authSource = flags.apiKey
|
|
467
|
+
? 'flag'
|
|
468
|
+
: process.env.POSTERLY_API_KEY
|
|
469
|
+
? 'env'
|
|
470
|
+
: config.apiKey
|
|
471
|
+
? 'config'
|
|
472
|
+
: null;
|
|
473
|
+
|
|
474
|
+
return {
|
|
475
|
+
config,
|
|
476
|
+
apiKey,
|
|
477
|
+
baseUrl,
|
|
478
|
+
authSource,
|
|
479
|
+
authType: authSource === 'env'
|
|
480
|
+
? 'env'
|
|
481
|
+
: authSource === 'flag'
|
|
482
|
+
? 'api_key'
|
|
483
|
+
: config.authType || (config.apiKey ? 'api_key' : null),
|
|
484
|
+
};
|
|
485
|
+
}
|
|
486
|
+
|
|
405
487
|
async function saveKey(key, flags) {
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
488
|
+
if (key || flags.apiKey) {
|
|
489
|
+
console.warn('Warning: passing API keys as command-line arguments can expose them through shell history or process listings. Prefer `posterly auth:key` with no argument or POSTERLY_API_KEY.');
|
|
490
|
+
}
|
|
491
|
+
|
|
492
|
+
const apiKey = key || flags.apiKey || process.env.POSTERLY_API_KEY || await readApiKeyFromInput();
|
|
493
|
+
if (!apiKey) {
|
|
494
|
+
throw new Error('Missing API key. Run `posterly auth:key` and paste a key at the prompt, pipe a key on stdin, use `npx @posterly/cli@latest auth:key`, or set POSTERLY_API_KEY.');
|
|
495
|
+
}
|
|
496
|
+
const baseUrl = normalizeBaseUrl(flags.url || process.env.POSTERLY_URL || DEFAULT_BASE_URL);
|
|
497
|
+
validateBaseUrlForKeyUse(baseUrl, flags, 'store an API key for');
|
|
409
498
|
const config = {
|
|
410
499
|
apiKey,
|
|
411
|
-
baseUrl
|
|
500
|
+
baseUrl,
|
|
412
501
|
updatedAt: new Date().toISOString(),
|
|
413
502
|
};
|
|
414
|
-
await
|
|
503
|
+
await writeConfig(config);
|
|
415
504
|
return print({ saved: true, config_file: CONFIG_FILE, base_url: config.baseUrl }, flags);
|
|
416
505
|
}
|
|
417
506
|
|
|
507
|
+
async function readApiKeyFromInput() {
|
|
508
|
+
if (!process.stdin.isTTY) {
|
|
509
|
+
const chunks = [];
|
|
510
|
+
for await (const chunk of process.stdin) {
|
|
511
|
+
chunks.push(Buffer.from(chunk));
|
|
512
|
+
}
|
|
513
|
+
return Buffer.concat(chunks).toString('utf8').trim();
|
|
514
|
+
}
|
|
515
|
+
|
|
516
|
+
if (!process.stdout.isTTY || typeof process.stdin.setRawMode !== 'function') {
|
|
517
|
+
return '';
|
|
518
|
+
}
|
|
519
|
+
|
|
520
|
+
process.stdout.write('Posterly API key: ');
|
|
521
|
+
process.stdin.setRawMode(true);
|
|
522
|
+
process.stdin.resume();
|
|
523
|
+
process.stdin.setEncoding('utf8');
|
|
524
|
+
|
|
525
|
+
let value = '';
|
|
526
|
+
try {
|
|
527
|
+
return await new Promise((resolve, reject) => {
|
|
528
|
+
const onData = (chunk) => {
|
|
529
|
+
if (chunk === '\u0003') {
|
|
530
|
+
cleanup();
|
|
531
|
+
process.stdout.write('\n');
|
|
532
|
+
reject(new Error('Cancelled'));
|
|
533
|
+
return;
|
|
534
|
+
}
|
|
535
|
+
if (chunk === '\r' || chunk === '\n') {
|
|
536
|
+
cleanup();
|
|
537
|
+
process.stdout.write('\n');
|
|
538
|
+
resolve(value.trim());
|
|
539
|
+
return;
|
|
540
|
+
}
|
|
541
|
+
if (chunk === '\u0008' || chunk === '\u007f') {
|
|
542
|
+
value = value.slice(0, -1);
|
|
543
|
+
return;
|
|
544
|
+
}
|
|
545
|
+
value += chunk;
|
|
546
|
+
};
|
|
547
|
+
const cleanup = () => {
|
|
548
|
+
process.stdin.off('data', onData);
|
|
549
|
+
process.stdin.setRawMode(false);
|
|
550
|
+
process.stdin.pause();
|
|
551
|
+
};
|
|
552
|
+
process.stdin.on('data', onData);
|
|
553
|
+
});
|
|
554
|
+
} finally {
|
|
555
|
+
if (process.stdin.isRaw) {
|
|
556
|
+
process.stdin.setRawMode(false);
|
|
557
|
+
}
|
|
558
|
+
}
|
|
559
|
+
}
|
|
560
|
+
|
|
418
561
|
async function authLogin(flags) {
|
|
419
562
|
const baseUrl = normalizeBaseUrl(flags.url || process.env.POSTERLY_URL || DEFAULT_BASE_URL);
|
|
563
|
+
validateBaseUrlForKeyUse(baseUrl, flags, 'start OAuth login against');
|
|
420
564
|
const redirectUri = `http://127.0.0.1:${OAUTH_CALLBACK_PORT}${OAUTH_CALLBACK_PATH}`;
|
|
421
565
|
const state = randomBytes(18).toString('base64url');
|
|
422
566
|
const codeVerifier = randomBytes(48).toString('base64url');
|
|
@@ -447,7 +591,6 @@ async function authLogin(flags) {
|
|
|
447
591
|
}
|
|
448
592
|
|
|
449
593
|
const token = await loginPromise;
|
|
450
|
-
await mkdir(CONFIG_DIR, { recursive: true });
|
|
451
594
|
const config = {
|
|
452
595
|
apiKey: token.access_token,
|
|
453
596
|
baseUrl,
|
|
@@ -456,7 +599,7 @@ async function authLogin(flags) {
|
|
|
456
599
|
expiresAt: token.expires_in ? new Date(Date.now() + Number(token.expires_in) * 1000).toISOString() : null,
|
|
457
600
|
updatedAt: new Date().toISOString(),
|
|
458
601
|
};
|
|
459
|
-
await
|
|
602
|
+
await writeConfig(config);
|
|
460
603
|
|
|
461
604
|
return print({
|
|
462
605
|
authenticated: true,
|
|
@@ -577,16 +720,18 @@ function errorHtml(message) {
|
|
|
577
720
|
}
|
|
578
721
|
|
|
579
722
|
async function authStatus(flags) {
|
|
580
|
-
const
|
|
581
|
-
const
|
|
723
|
+
const context = await resolveAuthContext(flags);
|
|
724
|
+
const baseUrlCheck = inspectBaseUrl(context.baseUrl);
|
|
582
725
|
return print({
|
|
583
|
-
authenticated: Boolean(
|
|
584
|
-
source:
|
|
585
|
-
base_url:
|
|
726
|
+
authenticated: Boolean(context.apiKey),
|
|
727
|
+
source: context.authSource,
|
|
728
|
+
base_url: context.baseUrl,
|
|
586
729
|
config_file: CONFIG_FILE,
|
|
587
|
-
auth_type:
|
|
588
|
-
scopes: config.scopes,
|
|
589
|
-
expires_at: config.expiresAt,
|
|
730
|
+
auth_type: context.authType,
|
|
731
|
+
scopes: context.config.scopes,
|
|
732
|
+
expires_at: context.config.expiresAt,
|
|
733
|
+
base_url_check: summarizeBaseUrlCheck(baseUrlCheck),
|
|
734
|
+
next_step: authStatusNextStep({ hasApiKey: Boolean(context.apiKey), baseUrlCheck }),
|
|
590
735
|
}, flags);
|
|
591
736
|
}
|
|
592
737
|
|
|
@@ -595,6 +740,58 @@ async function logout(flags) {
|
|
|
595
740
|
return print({ logged_out: true, config_file: CONFIG_FILE }, flags);
|
|
596
741
|
}
|
|
597
742
|
|
|
743
|
+
async function doctor(flags) {
|
|
744
|
+
const context = await resolveAuthContext(flags);
|
|
745
|
+
const packageInfo = await readPackageInfo();
|
|
746
|
+
const baseUrlCheck = inspectBaseUrl(context.baseUrl);
|
|
747
|
+
const checks = [
|
|
748
|
+
nodeVersionCheck(),
|
|
749
|
+
{
|
|
750
|
+
name: 'base_url',
|
|
751
|
+
ok: baseUrlCheck.valid && (baseUrlCheck.secure || flagEnabled(flags.allowInsecureUrl)),
|
|
752
|
+
severity: baseUrlSeverity(baseUrlCheck, flags),
|
|
753
|
+
value: context.baseUrl,
|
|
754
|
+
...summarizeBaseUrlCheck(baseUrlCheck),
|
|
755
|
+
},
|
|
756
|
+
{
|
|
757
|
+
name: 'auth_config',
|
|
758
|
+
ok: Boolean(context.apiKey),
|
|
759
|
+
severity: context.apiKey ? 'info' : 'error',
|
|
760
|
+
source: context.authSource,
|
|
761
|
+
config_file: CONFIG_FILE,
|
|
762
|
+
message: context.apiKey
|
|
763
|
+
? `API key found via ${context.authSource}.`
|
|
764
|
+
: 'No API key found in POSTERLY_API_KEY, --api-key, or local config.',
|
|
765
|
+
},
|
|
766
|
+
];
|
|
767
|
+
|
|
768
|
+
const latest = flagEnabled(flags.noNpm)
|
|
769
|
+
? { skipped: true, reason: '--no-npm' }
|
|
770
|
+
: await fetchLatestCliVersion();
|
|
771
|
+
checks.push(npmVersionCheck(packageInfo.version, latest));
|
|
772
|
+
|
|
773
|
+
const canProbeApi = context.apiKey && baseUrlCheck.valid && (baseUrlCheck.secure || flagEnabled(flags.allowInsecureUrl));
|
|
774
|
+
const authProbe = canProbeApi
|
|
775
|
+
? await probeWhoami(context.baseUrl, context.apiKey)
|
|
776
|
+
: null;
|
|
777
|
+
checks.push(apiAuthCheck(authProbe, { skippedBecause: context.apiKey ? 'base_url' : 'auth_config' }));
|
|
778
|
+
|
|
779
|
+
const ok = checks.every((check) => check.severity !== 'error');
|
|
780
|
+
if (!ok) {
|
|
781
|
+
process.exitCode = 1;
|
|
782
|
+
}
|
|
783
|
+
return print({
|
|
784
|
+
ok,
|
|
785
|
+
package: packageInfo,
|
|
786
|
+
base_url: context.baseUrl,
|
|
787
|
+
checks,
|
|
788
|
+
user: authProbe?.ok ? authProbe.user : undefined,
|
|
789
|
+
default_workspace: authProbe?.ok ? authProbe.default_workspace : undefined,
|
|
790
|
+
scopes: authProbe?.ok ? authProbe.scopes : undefined,
|
|
791
|
+
next_step: doctorNextStep({ checks, latest, authProbe }),
|
|
792
|
+
}, flags);
|
|
793
|
+
}
|
|
794
|
+
|
|
598
795
|
async function readConfig() {
|
|
599
796
|
try {
|
|
600
797
|
return JSON.parse(await readFile(CONFIG_FILE, 'utf8'));
|
|
@@ -603,6 +800,33 @@ async function readConfig() {
|
|
|
603
800
|
}
|
|
604
801
|
}
|
|
605
802
|
|
|
803
|
+
async function ensureConfigDir() {
|
|
804
|
+
await mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
|
|
805
|
+
await chmodIfPresent(CONFIG_DIR, 0o700);
|
|
806
|
+
}
|
|
807
|
+
|
|
808
|
+
async function writeConfig(config) {
|
|
809
|
+
await ensureConfigDir();
|
|
810
|
+
const tempFile = path.join(CONFIG_DIR, `.config.${process.pid}.${randomBytes(6).toString('hex')}.tmp`);
|
|
811
|
+
try {
|
|
812
|
+
await writeFile(tempFile, `${JSON.stringify(config, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
|
|
813
|
+
await chmodIfPresent(tempFile, 0o600);
|
|
814
|
+
await rename(tempFile, CONFIG_FILE);
|
|
815
|
+
await chmodIfPresent(CONFIG_FILE, 0o600);
|
|
816
|
+
} catch (error) {
|
|
817
|
+
await rm(tempFile, { force: true }).catch(() => {});
|
|
818
|
+
throw error;
|
|
819
|
+
}
|
|
820
|
+
}
|
|
821
|
+
|
|
822
|
+
async function chmodIfPresent(filePath, mode) {
|
|
823
|
+
try {
|
|
824
|
+
await chmod(filePath, mode);
|
|
825
|
+
} catch {
|
|
826
|
+
// Best-effort hardening for filesystems that do not fully support POSIX modes.
|
|
827
|
+
}
|
|
828
|
+
}
|
|
829
|
+
|
|
606
830
|
async function postPayloadFromFlags(flags) {
|
|
607
831
|
if (flags.file) return validatePostPayload(await readJson(required(flags.file, '--file')));
|
|
608
832
|
return clean({
|
|
@@ -804,6 +1028,22 @@ function validatePostStatus(value) {
|
|
|
804
1028
|
return status;
|
|
805
1029
|
}
|
|
806
1030
|
|
|
1031
|
+
function validateGoogleBusinessMediaCategory(value) {
|
|
1032
|
+
const category = String(value || '').trim().toUpperCase();
|
|
1033
|
+
if (!GOOGLE_BUSINESS_MEDIA_CATEGORIES.includes(category)) {
|
|
1034
|
+
throw new Error(`Unknown Google Business media category "${value}". Allowed categories: ${formatList(GOOGLE_BUSINESS_MEDIA_CATEGORIES)}.`);
|
|
1035
|
+
}
|
|
1036
|
+
return category;
|
|
1037
|
+
}
|
|
1038
|
+
|
|
1039
|
+
function validateGoogleBusinessMediaFormat(value) {
|
|
1040
|
+
const format = String(value || '').trim().toUpperCase();
|
|
1041
|
+
if (!['PHOTO', 'VIDEO'].includes(format)) {
|
|
1042
|
+
throw new Error(`Unknown Google Business media format "${value}". Allowed formats: PHOTO, VIDEO.`);
|
|
1043
|
+
}
|
|
1044
|
+
return format;
|
|
1045
|
+
}
|
|
1046
|
+
|
|
807
1047
|
function normalizeManifestKey(value) {
|
|
808
1048
|
return String(value || '').trim().toLowerCase().replace(/[\s-]+/g, '_');
|
|
809
1049
|
}
|
|
@@ -823,7 +1063,338 @@ function flagEnabled(value) {
|
|
|
823
1063
|
}
|
|
824
1064
|
|
|
825
1065
|
function normalizeBaseUrl(value) {
|
|
826
|
-
|
|
1066
|
+
const raw = String(value || DEFAULT_BASE_URL).trim();
|
|
1067
|
+
try {
|
|
1068
|
+
const url = new URL(raw);
|
|
1069
|
+
url.pathname = url.pathname.replace(/\/api\/v1\/?$/, '').replace(/\/+$/, '') || '/';
|
|
1070
|
+
url.search = '';
|
|
1071
|
+
url.hash = '';
|
|
1072
|
+
return url.toString().replace(/\/$/, '');
|
|
1073
|
+
} catch {
|
|
1074
|
+
return raw.replace(/\/api\/v1\/?$/, '').replace(/\/$/, '');
|
|
1075
|
+
}
|
|
1076
|
+
}
|
|
1077
|
+
|
|
1078
|
+
function inspectBaseUrl(baseUrl) {
|
|
1079
|
+
try {
|
|
1080
|
+
const url = new URL(baseUrl);
|
|
1081
|
+
const hostname = url.hostname.toLowerCase().replace(/^\[|\]$/g, '');
|
|
1082
|
+
const local = isLocalHost(hostname);
|
|
1083
|
+
const trustedPosterlyHost = TRUSTED_POSTERLY_HOSTS.has(hostname);
|
|
1084
|
+
const secure = url.protocol === 'https:' || (url.protocol === 'http:' && local);
|
|
1085
|
+
const warnings = [];
|
|
1086
|
+
if (!trustedPosterlyHost) {
|
|
1087
|
+
warnings.push(local ? 'local_development_host' : 'custom_host');
|
|
1088
|
+
}
|
|
1089
|
+
if (!secure) {
|
|
1090
|
+
warnings.push('insecure_non_local_url');
|
|
1091
|
+
}
|
|
1092
|
+
|
|
1093
|
+
return {
|
|
1094
|
+
valid: true,
|
|
1095
|
+
secure,
|
|
1096
|
+
protocol: url.protocol.replace(/:$/, ''),
|
|
1097
|
+
host: url.host,
|
|
1098
|
+
trusted_posterly_host: trustedPosterlyHost,
|
|
1099
|
+
local_development_host: local,
|
|
1100
|
+
warnings,
|
|
1101
|
+
message: baseUrlMessage({ secure, trustedPosterlyHost, local }),
|
|
1102
|
+
};
|
|
1103
|
+
} catch {
|
|
1104
|
+
return {
|
|
1105
|
+
valid: false,
|
|
1106
|
+
secure: false,
|
|
1107
|
+
warnings: ['invalid_url'],
|
|
1108
|
+
message: 'Base URL must include a scheme and host, for example https://www.poster.ly.',
|
|
1109
|
+
};
|
|
1110
|
+
}
|
|
1111
|
+
}
|
|
1112
|
+
|
|
1113
|
+
function summarizeBaseUrlCheck(check) {
|
|
1114
|
+
return clean({
|
|
1115
|
+
valid: check.valid,
|
|
1116
|
+
secure: check.secure,
|
|
1117
|
+
protocol: check.protocol,
|
|
1118
|
+
host: check.host,
|
|
1119
|
+
trusted_posterly_host: check.trusted_posterly_host,
|
|
1120
|
+
local_development_host: check.local_development_host,
|
|
1121
|
+
warnings: check.warnings,
|
|
1122
|
+
message: check.message,
|
|
1123
|
+
});
|
|
1124
|
+
}
|
|
1125
|
+
|
|
1126
|
+
function baseUrlSeverity(check, flags) {
|
|
1127
|
+
if (!check.valid) return 'error';
|
|
1128
|
+
if (!check.secure && !flagEnabled(flags.allowInsecureUrl)) return 'error';
|
|
1129
|
+
if (!check.trusted_posterly_host) return 'warning';
|
|
1130
|
+
return 'info';
|
|
1131
|
+
}
|
|
1132
|
+
|
|
1133
|
+
function validateBaseUrlForKeyUse(baseUrl, flags, action) {
|
|
1134
|
+
const check = inspectBaseUrl(baseUrl);
|
|
1135
|
+
if (!check.valid) {
|
|
1136
|
+
throw new Error(`${check.message} Received: ${baseUrl}`);
|
|
1137
|
+
}
|
|
1138
|
+
if (!check.secure && !flagEnabled(flags.allowInsecureUrl)) {
|
|
1139
|
+
throw new Error(`Refusing to ${action} ${baseUrl}. Use https, http://localhost for local development, or re-run with --allow-insecure-url only for a trusted private development endpoint.`);
|
|
1140
|
+
}
|
|
1141
|
+
}
|
|
1142
|
+
|
|
1143
|
+
function baseUrlMessage({ secure, trustedPosterlyHost, local }) {
|
|
1144
|
+
if (!secure) {
|
|
1145
|
+
return 'Non-local HTTP URLs are blocked for API-key requests.';
|
|
1146
|
+
}
|
|
1147
|
+
if (local) {
|
|
1148
|
+
return 'Local development URL accepted.';
|
|
1149
|
+
}
|
|
1150
|
+
if (!trustedPosterlyHost) {
|
|
1151
|
+
return 'Custom HTTPS host accepted; verify it is your intended posterly deployment before sending API keys.';
|
|
1152
|
+
}
|
|
1153
|
+
return 'Official posterly API host.';
|
|
1154
|
+
}
|
|
1155
|
+
|
|
1156
|
+
function isLocalHost(hostname) {
|
|
1157
|
+
return hostname === 'localhost'
|
|
1158
|
+
|| hostname.endsWith('.localhost')
|
|
1159
|
+
|| hostname === '::1'
|
|
1160
|
+
|| hostname === '0.0.0.0'
|
|
1161
|
+
|| hostname === '127.0.0.1'
|
|
1162
|
+
|| hostname.startsWith('127.');
|
|
1163
|
+
}
|
|
1164
|
+
|
|
1165
|
+
let packageInfoCache;
|
|
1166
|
+
|
|
1167
|
+
async function readPackageInfo() {
|
|
1168
|
+
if (packageInfoCache) return packageInfoCache;
|
|
1169
|
+
try {
|
|
1170
|
+
const pkg = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8'));
|
|
1171
|
+
packageInfoCache = {
|
|
1172
|
+
name: typeof pkg.name === 'string' ? pkg.name : CLI_PACKAGE_NAME,
|
|
1173
|
+
version: typeof pkg.version === 'string' ? pkg.version : 'unknown',
|
|
1174
|
+
};
|
|
1175
|
+
} catch {
|
|
1176
|
+
packageInfoCache = { name: CLI_PACKAGE_NAME, version: 'unknown' };
|
|
1177
|
+
}
|
|
1178
|
+
return packageInfoCache;
|
|
1179
|
+
}
|
|
1180
|
+
|
|
1181
|
+
function nodeVersionCheck() {
|
|
1182
|
+
const major = Number.parseInt(process.versions.node.split('.')[0], 10);
|
|
1183
|
+
const ok = Number.isFinite(major) && major >= REQUIRED_NODE_MAJOR;
|
|
1184
|
+
return {
|
|
1185
|
+
name: 'node',
|
|
1186
|
+
ok,
|
|
1187
|
+
severity: ok ? 'info' : 'error',
|
|
1188
|
+
version: process.version,
|
|
1189
|
+
required: `>=${REQUIRED_NODE_MAJOR}`,
|
|
1190
|
+
message: ok
|
|
1191
|
+
? 'Node version is supported.'
|
|
1192
|
+
: `Node ${REQUIRED_NODE_MAJOR}+ is required.`,
|
|
1193
|
+
};
|
|
1194
|
+
}
|
|
1195
|
+
|
|
1196
|
+
function npmVersionCheck(currentVersion, latest) {
|
|
1197
|
+
if (latest.skipped) {
|
|
1198
|
+
return {
|
|
1199
|
+
name: 'npm_latest',
|
|
1200
|
+
ok: true,
|
|
1201
|
+
severity: 'info',
|
|
1202
|
+
skipped: true,
|
|
1203
|
+
message: `Skipped npm latest check (${latest.reason}).`,
|
|
1204
|
+
};
|
|
1205
|
+
}
|
|
1206
|
+
if (latest.error) {
|
|
1207
|
+
return {
|
|
1208
|
+
name: 'npm_latest',
|
|
1209
|
+
ok: false,
|
|
1210
|
+
severity: 'warning',
|
|
1211
|
+
current_version: currentVersion,
|
|
1212
|
+
message: latest.error,
|
|
1213
|
+
};
|
|
1214
|
+
}
|
|
1215
|
+
|
|
1216
|
+
const comparison = compareSemver(currentVersion, latest.version);
|
|
1217
|
+
return {
|
|
1218
|
+
name: 'npm_latest',
|
|
1219
|
+
ok: comparison >= 0,
|
|
1220
|
+
severity: comparison < 0 ? 'warning' : 'info',
|
|
1221
|
+
current_version: currentVersion,
|
|
1222
|
+
latest_version: latest.version,
|
|
1223
|
+
update_status: comparison < 0
|
|
1224
|
+
? 'update_available'
|
|
1225
|
+
: comparison > 0
|
|
1226
|
+
? 'newer_than_npm'
|
|
1227
|
+
: 'current',
|
|
1228
|
+
message: comparison < 0
|
|
1229
|
+
? `Update available: ${latest.version}.`
|
|
1230
|
+
: comparison > 0
|
|
1231
|
+
? 'Local package is newer than npm latest; publish may still be pending.'
|
|
1232
|
+
: 'CLI package is current.',
|
|
1233
|
+
};
|
|
1234
|
+
}
|
|
1235
|
+
|
|
1236
|
+
function apiAuthCheck(probe, { skippedBecause }) {
|
|
1237
|
+
if (!probe) {
|
|
1238
|
+
return {
|
|
1239
|
+
name: 'api_auth',
|
|
1240
|
+
ok: false,
|
|
1241
|
+
severity: 'error',
|
|
1242
|
+
skipped: true,
|
|
1243
|
+
skipped_because: skippedBecause,
|
|
1244
|
+
message: skippedBecause === 'auth_config'
|
|
1245
|
+
? 'Skipped because no API key is configured.'
|
|
1246
|
+
: 'Skipped because the base URL is not safe for API-key requests.',
|
|
1247
|
+
};
|
|
1248
|
+
}
|
|
1249
|
+
|
|
1250
|
+
if (probe.ok) {
|
|
1251
|
+
return {
|
|
1252
|
+
name: 'api_auth',
|
|
1253
|
+
ok: true,
|
|
1254
|
+
severity: 'info',
|
|
1255
|
+
status: probe.status,
|
|
1256
|
+
duration_ms: probe.duration_ms,
|
|
1257
|
+
message: 'API key validated against /api/v1/whoami.',
|
|
1258
|
+
};
|
|
1259
|
+
}
|
|
1260
|
+
|
|
1261
|
+
return {
|
|
1262
|
+
name: 'api_auth',
|
|
1263
|
+
ok: false,
|
|
1264
|
+
severity: 'error',
|
|
1265
|
+
status: probe.status,
|
|
1266
|
+
duration_ms: probe.duration_ms,
|
|
1267
|
+
message: probe.error || 'API key validation failed.',
|
|
1268
|
+
};
|
|
1269
|
+
}
|
|
1270
|
+
|
|
1271
|
+
async function probeWhoami(baseUrl, apiKey, timeoutMs = REQUEST_TIMEOUT_MS) {
|
|
1272
|
+
const startedAt = Date.now();
|
|
1273
|
+
const controller = new AbortController();
|
|
1274
|
+
const timeout = setTimeout(() => controller.abort(), timeoutMs);
|
|
1275
|
+
|
|
1276
|
+
try {
|
|
1277
|
+
const res = await fetch(`${baseUrl}/api/v1/whoami`, {
|
|
1278
|
+
method: 'GET',
|
|
1279
|
+
headers: {
|
|
1280
|
+
Authorization: `Bearer ${apiKey}`,
|
|
1281
|
+
Accept: 'application/json',
|
|
1282
|
+
'X-Posterly-Source': 'cli_doctor',
|
|
1283
|
+
},
|
|
1284
|
+
signal: controller.signal,
|
|
1285
|
+
});
|
|
1286
|
+
const text = await res.text();
|
|
1287
|
+
const data = text ? safeJson(text) : {};
|
|
1288
|
+
if (!res.ok) {
|
|
1289
|
+
return {
|
|
1290
|
+
ok: false,
|
|
1291
|
+
status: res.status,
|
|
1292
|
+
duration_ms: Date.now() - startedAt,
|
|
1293
|
+
error: formatResponseError(data, text, res.statusText),
|
|
1294
|
+
};
|
|
1295
|
+
}
|
|
1296
|
+
return {
|
|
1297
|
+
ok: true,
|
|
1298
|
+
status: res.status,
|
|
1299
|
+
duration_ms: Date.now() - startedAt,
|
|
1300
|
+
user: data.user,
|
|
1301
|
+
default_workspace: data.default_workspace,
|
|
1302
|
+
scopes: Array.isArray(data.api_key?.scopes) ? data.api_key.scopes : undefined,
|
|
1303
|
+
};
|
|
1304
|
+
} catch (error) {
|
|
1305
|
+
return {
|
|
1306
|
+
ok: false,
|
|
1307
|
+
duration_ms: Date.now() - startedAt,
|
|
1308
|
+
error: error?.name === 'AbortError' ? `timed out after ${timeoutMs}ms` : error?.message || String(error),
|
|
1309
|
+
};
|
|
1310
|
+
} finally {
|
|
1311
|
+
clearTimeout(timeout);
|
|
1312
|
+
}
|
|
1313
|
+
}
|
|
1314
|
+
|
|
1315
|
+
async function fetchLatestCliVersion() {
|
|
1316
|
+
const controller = new AbortController();
|
|
1317
|
+
const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
|
|
1318
|
+
|
|
1319
|
+
try {
|
|
1320
|
+
const res = await fetch(CLI_NPM_LATEST_URL, {
|
|
1321
|
+
headers: { Accept: 'application/json' },
|
|
1322
|
+
signal: controller.signal,
|
|
1323
|
+
});
|
|
1324
|
+
if (!res.ok) {
|
|
1325
|
+
return { error: `npm registry returned HTTP ${res.status}` };
|
|
1326
|
+
}
|
|
1327
|
+
const data = await res.json();
|
|
1328
|
+
return typeof data.version === 'string'
|
|
1329
|
+
? { version: data.version }
|
|
1330
|
+
: { error: 'npm registry response did not include a version' };
|
|
1331
|
+
} catch (error) {
|
|
1332
|
+
const reason = error?.name === 'AbortError' ? 'timed out' : error?.message || String(error);
|
|
1333
|
+
return { error: `could not check npm latest: ${reason}` };
|
|
1334
|
+
} finally {
|
|
1335
|
+
clearTimeout(timeout);
|
|
1336
|
+
}
|
|
1337
|
+
}
|
|
1338
|
+
|
|
1339
|
+
function authStatusNextStep({ hasApiKey, baseUrlCheck }) {
|
|
1340
|
+
if (!baseUrlCheck.valid) {
|
|
1341
|
+
return 'Fix POSTERLY_URL or --url so it includes a scheme and host.';
|
|
1342
|
+
}
|
|
1343
|
+
if (!baseUrlCheck.secure) {
|
|
1344
|
+
return 'Use an https posterly URL, or http://localhost for local development.';
|
|
1345
|
+
}
|
|
1346
|
+
if (!hasApiKey) {
|
|
1347
|
+
return 'Run `posterly auth:login`, `posterly auth:key`, or set POSTERLY_API_KEY.';
|
|
1348
|
+
}
|
|
1349
|
+
return 'Run `posterly doctor --pretty` to validate the API key against /api/v1/whoami.';
|
|
1350
|
+
}
|
|
1351
|
+
|
|
1352
|
+
function doctorNextStep({ checks, latest, authProbe }) {
|
|
1353
|
+
const byName = Object.fromEntries(checks.map((check) => [check.name, check]));
|
|
1354
|
+
if (byName.node?.severity === 'error') {
|
|
1355
|
+
return 'Install Node 20 or newer, then run `posterly doctor --pretty` again.';
|
|
1356
|
+
}
|
|
1357
|
+
if (byName.base_url?.severity === 'error') {
|
|
1358
|
+
return 'Fix POSTERLY_URL or --url before sending an API key.';
|
|
1359
|
+
}
|
|
1360
|
+
if (byName.auth_config?.severity === 'error') {
|
|
1361
|
+
return 'Run `posterly auth:login`, `posterly auth:key`, or set POSTERLY_API_KEY.';
|
|
1362
|
+
}
|
|
1363
|
+
if (byName.api_auth?.severity === 'error') {
|
|
1364
|
+
return 'Check the API key and base URL, then run `posterly whoami --pretty`.';
|
|
1365
|
+
}
|
|
1366
|
+
if (latest.version && compareSemver((byName.npm_latest?.current_version || '0.0.0'), latest.version) < 0) {
|
|
1367
|
+
return 'Update with `npm i -g @posterly/cli@latest`, or keep using `npx @posterly/cli@latest`.';
|
|
1368
|
+
}
|
|
1369
|
+
if (authProbe?.ok) {
|
|
1370
|
+
return 'CLI is ready. Try `posterly accounts:list --pretty` or `posterly platforms:list --pretty`.';
|
|
1371
|
+
}
|
|
1372
|
+
return 'Run `posterly whoami --pretty` after configuring auth.';
|
|
1373
|
+
}
|
|
1374
|
+
|
|
1375
|
+
function formatResponseError(data, fallback, statusText) {
|
|
1376
|
+
if (data && typeof data === 'object') {
|
|
1377
|
+
return data.error || data.message || data.code || statusText || 'API request failed';
|
|
1378
|
+
}
|
|
1379
|
+
return fallback || statusText || 'API request failed';
|
|
1380
|
+
}
|
|
1381
|
+
|
|
1382
|
+
function compareSemver(a, b) {
|
|
1383
|
+
const left = semverParts(a);
|
|
1384
|
+
const right = semverParts(b);
|
|
1385
|
+
for (let i = 0; i < 3; i += 1) {
|
|
1386
|
+
if (left[i] !== right[i]) return left[i] > right[i] ? 1 : -1;
|
|
1387
|
+
}
|
|
1388
|
+
return 0;
|
|
1389
|
+
}
|
|
1390
|
+
|
|
1391
|
+
function semverParts(value) {
|
|
1392
|
+
const parts = String(value || '').split(/[.-]/).slice(0, 3).map((part) => Number.parseInt(part, 10));
|
|
1393
|
+
return [
|
|
1394
|
+
Number.isFinite(parts[0]) ? parts[0] : 0,
|
|
1395
|
+
Number.isFinite(parts[1]) ? parts[1] : 0,
|
|
1396
|
+
Number.isFinite(parts[2]) ? parts[2] : 0,
|
|
1397
|
+
];
|
|
827
1398
|
}
|
|
828
1399
|
|
|
829
1400
|
function safeJson(text) {
|
package/package.json
CHANGED
|
@@ -1,12 +1,15 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@posterly/cli",
|
|
3
|
-
"version": "0.1.
|
|
3
|
+
"version": "0.1.4",
|
|
4
4
|
"description": "Command line interface for the posterly API",
|
|
5
5
|
"license": "MIT",
|
|
6
6
|
"type": "module",
|
|
7
7
|
"bin": {
|
|
8
8
|
"posterly": "bin/posterly.mjs"
|
|
9
9
|
},
|
|
10
|
+
"publishConfig": {
|
|
11
|
+
"access": "public"
|
|
12
|
+
},
|
|
10
13
|
"engines": {
|
|
11
14
|
"node": ">=20"
|
|
12
15
|
}
|