@zergai/cyberdeck 0.1.0-beta.1

package/dist/config.js

@@ -0,0 +1,48 @@
+/**
+ * CLI config — persisted to ~/.config/zergcyberdeck/config.json (0600).
+ * Env overrides win: ZERGCYBERDECK_BASE_URL, ZERGCYBERDECK_TOKEN.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const DEFAULT_BASE = 'https://zergcyberdeck.com';
+function configDir() {
+    return process.env.ZERGCYBERDECK_CONFIG_DIR || path.join(os.homedir(), '.config', 'zergcyberdeck');
+}
+export function configFilePath() {
+    return path.join(configDir(), 'config.json');
+}
+export function loadConfig() {
+    let file = {};
+    try {
+        file = JSON.parse(fs.readFileSync(configFilePath(), 'utf8'));
+    }
+    catch {
+        // no config yet — fall back to defaults + env
+    }
+    const baseUrl = (process.env.ZERGCYBERDECK_BASE_URL || file.baseUrl || DEFAULT_BASE).replace(/\/+$/, '');
+    return {
+        baseUrl,
+        token: process.env.ZERGCYBERDECK_TOKEN || file.token,
+        expiresAt: file.expiresAt,
+        workspace: file.workspace,
+    };
+}
+export function saveConfig(cfg) {
+    const dir = configDir();
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    try {
+        fs.chmodSync(dir, 0o700);
+    }
+    catch {
+        // best-effort on platforms without chmod
+    }
+    fs.writeFileSync(configFilePath(), JSON.stringify(cfg, null, 2), { mode: 0o600 });
+    try {
+        fs.chmodSync(configFilePath(), 0o600);
+    }
+    catch {
+        // best-effort on platforms without chmod
+    }
+}
+//# sourceMappingURL=config.js.map

package/dist/fleet.js

@@ -0,0 +1,88 @@
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const LOG_CREDENTIAL_KEY = /(authorization|credential|password|passwd|secret|token|api[_-]?key|access[_-]?key|client[_-]?secret)/i;
+const LOG_CREDENTIAL_PAIR = /\b((?:[A-Za-z0-9]+[_-])*(?:authorization|credential|password|passwd|secret|token|api[_-]?key|access[_-]?key|client[_-]?secret)(?:[_-][A-Za-z0-9]+)*)\b["']?\s*([=:])\s*(?:"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*'|[^\s,;&"']+)/gi;
+const LOG_AUTHORIZATION_HEADER = /\b(?:proxy-)?authorization\s*[:=]\s*[^\r\n,;]+/gi;
+const LOG_AUTHORIZATION = /\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]+/gi;
+const LOG_JWT = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g;
+function redactLogText(value) {
+    return value
+        .replace(LOG_AUTHORIZATION_HEADER, 'Authorization: [REDACTED]')
+        .replace(LOG_AUTHORIZATION, '$1 [REDACTED]')
+        .replace(LOG_CREDENTIAL_PAIR, '$1$2[REDACTED]')
+        .replace(LOG_JWT, '[REDACTED]');
+}
+export function redactLogValue(value, depth = 0) {
+    if (depth > 20)
+        return '[TRUNCATED]';
+    if (typeof value === 'string')
+        return redactLogText(value);
+    if (Array.isArray(value)) {
+        return value.map(item => redactLogValue(item, depth + 1));
+    }
+    if (typeof value !== 'object' || value === null)
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key,
+        LOG_CREDENTIAL_KEY.test(key)
+            ? '[REDACTED]'
+            : redactLogValue(item, depth + 1),
+    ]));
+}
+export function uniqueStrings(values) {
+    return [...new Set(values)];
+}
+export function isTerminalRun(status) {
+    return status === 'completed' || status === 'failed' || status === 'partial';
+}
+export function runHasFailures(envelope) {
+    return (envelope.run.status === 'failed'
+        || envelope.run.status === 'partial'
+        || envelope.run.failedCount > 0
+        || envelope.clones.some(clone => clone.status === 'failed'));
+}
+export function diagnosticHasFailure(clone) {
+    return (clone.status === 'error'
+        || clone.error !== null
+        || clone.latestFailure !== null
+        || clone.operation?.status === 'failed');
+}
+export function diagnosticsHaveFailures(diagnostics) {
+    return diagnostics.clones.some(diagnosticHasFailure);
+}
+export function selectDiagnostic(diagnostics, selector) {
+    const value = selector.trim();
+    if (!value) {
+        throw new Error('--clone must name a vendor or clone UUID.');
+    }
+    if (UUID.test(value)) {
+        const match = diagnostics.clones.find(clone => clone.cloneId.toLowerCase() === value.toLowerCase());
+        if (match)
+            return match;
+        throw new Error(`Clone UUID '${value}' was not found in deck ${diagnostics.deck.id}.`);
+    }
+    const vendor = value.toLowerCase();
+    const matches = diagnostics.clones.filter(clone => clone.vendor.toLowerCase() === vendor);
+    if (matches.length === 0) {
+        throw new Error(`Clone selector '${value}' did not match a clone in deck `
+            + `${diagnostics.deck.id}.`);
+    }
+    if (matches.length > 1) {
+        throw new Error(`Clone vendor '${vendor}' is ambiguous in deck ${diagnostics.deck.id}. `
+            + `Matching clone IDs: ${matches.map(clone => clone.cloneId).join(', ')}.`);
+    }
+    return matches[0];
+}
+export async function mapLimit(values, concurrency, operation) {
+    const results = new Array(values.length);
+    let next = 0;
+    const workers = Array.from({ length: Math.min(Math.max(1, concurrency), values.length) }, async () => {
+        while (next < values.length) {
+            const index = next;
+            next += 1;
+            results[index] = await operation(values[index]);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}
+//# sourceMappingURL=fleet.js.map

package/dist/index.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+/**
+ * zcd — ZergCyberDeck CLI.
+ *
+ * Drives the deck API (against the canonical zergcyberdeck.com origin by default) to
+ * spin up a deck of zerg-clones, seed prebaked synthetic data, and check that
+ * each clone's vendor API + its zerg are healthy — the fast path for test/QA/dev
+ * of the platform.
+ */
+import { createRequire } from 'node:module';
+import { Command } from 'commander';
+import { registerAuthCommands } from './commands/auth.js';
+import { registerAutomationCommands } from './commands/automation.js';
+import { registerDeckCommands } from './commands/decks.js';
+import { registerFleetCommands } from './commands/fleet.js';
+import { registerSdkCommand } from './commands/sdk.js';
+import { registerWorkbenchCommands } from './commands/workbench.js';
+import { registerOracleCommands } from './commands/oracle.js';
+import { registerPortfolioCommand } from './commands/portfolio.js';
+import { registerScenarioCommands } from './commands/scenarios.js';
+const program = new Command();
+const packageMetadata = createRequire(import.meta.url)('../package.json');
+program
+    .name('zcd')
+    .description('ZergCyberDeck CLI — spin up decks of zerg-clones, seed data, check everything')
+    .version(packageMetadata.version);
+registerAuthCommands(program);
+registerDeckCommands(program);
+registerFleetCommands(program);
+registerAutomationCommands(program);
+registerSdkCommand(program);
+registerWorkbenchCommands(program);
+registerOracleCommands(program);
+registerPortfolioCommand(program);
+registerScenarioCommands(program);
+program.parseAsync(process.argv).catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    if (process.env.ZCD_DEBUG && err instanceof Error && err.stack) {
+        console.error(err.stack);
+    }
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/portfolio.js

@@ -0,0 +1,148 @@
+export const PORTFOLIO_DIMENSIONS = [
+    'genericRuntime',
+    'vendorApi',
+    'officialSdkOrNativeProtocol',
+    'connectorWorkflow',
+    'deployedQualification',
+];
+const EVIDENCE_STATUSES = new Set([
+    'passing', 'partial', 'failing', 'not_run', 'not_applicable',
+]);
+const CERTIFICATIONS = new Set([
+    'certified', 'blocked', 'stale', 'unqualified', 'not_applicable',
+]);
+export function parseDeckPortfolio(value, label) {
+    if (!isRecord(value)
+        || value.schemaVersion !== 2
+        || value.catalogTargetCount !== 69
+        || !canonicalTimestamp(value.generatedAt)
+        || !Array.isArray(value.targets)
+        || value.targets.length !== 69) {
+        throw new Error(`${label} returned an invalid portfolio denominator`);
+    }
+    const targets = value.targets.map((target, index) => parseTarget(target, `${label} targets[${index}]`));
+    const ids = targets.map(target => target.targetId);
+    if (new Set(ids).size !== ids.length || targets.filter(target => target.kind === 'platform').length !== 1) {
+        throw new Error(`${label} returned an invalid portfolio target catalog`);
+    }
+    return value;
+}
+export function renderDeckPortfolio(portfolio) {
+    const connectorCount = portfolio.targets.filter(target => target.kind === 'connector').length;
+    const certified = portfolio.targets.filter(target => target.certification === 'certified').length;
+    const lines = [
+        `Portfolio v2 · ${connectorCount} connector targets · ${certified} certified`,
+        `Evidence as of ${portfolio.generatedAt}`,
+        '',
+    ];
+    for (const target of portfolio.targets) {
+        if (target.kind === 'platform') {
+            lines.push(`${target.targetId} platform-exempt — ${target.exemption.reason}`);
+            continue;
+        }
+        const dimensions = [
+            ['runtime', target.dimensions.genericRuntime],
+            ['vendor-api', target.dimensions.vendorApi],
+            ['sdk-protocol', target.dimensions.officialSdkOrNativeProtocol],
+            ['workflow', target.dimensions.connectorWorkflow],
+            ['qualification', target.dimensions.deployedQualification],
+        ];
+        lines.push(`${target.targetId} ${target.certification} · ${dimensions
+            .map(([name, dimension]) => `${name}=${renderDimension(dimension)}`)
+            .join(' ')}`);
+    }
+    return lines.join('\n');
+}
+function parseTarget(value, label) {
+    if (!isRecord(value)
+        || typeof value.targetId !== 'string'
+        || !value.targetId.trim()
+        || (value.kind !== 'connector' && value.kind !== 'platform')
+        || !['dedicated', 'shared', 'platform'].includes(String(value.implementation))
+        || !CERTIFICATIONS.has(value.certification)
+        || !['ready', 'failed', 'not_built', 'not_observed'].includes(String(value.build))
+        || (value.exactArtifact !== null && !validArtifact(value.exactArtifact))
+        || !isRecord(value.suite)
+        || !Number.isSafeInteger(value.suite.caseCount)
+        || Number(value.suite.caseCount) < 0
+        || (value.suite.version !== null && typeof value.suite.version !== 'string')
+        || !isRecord(value.dimensions)
+        || !stringArray(value.parityGaps)
+        || !stringArray(value.deploymentConflicts)
+        || !stringArray(value.knownBlockers)) {
+        throw new Error(`${label} is invalid`);
+    }
+    const dimensionRecord = value.dimensions;
+    const dimensions = Object.fromEntries(PORTFOLIO_DIMENSIONS.map(name => [
+        name,
+        parseDimension(dimensionRecord[name], `${label} ${name}`),
+    ]));
+    const exemption = value.exemption === null
+        ? null
+        : isRecord(value.exemption)
+            && value.exemption.status === 'platform_exempt'
+            && typeof value.exemption.reason === 'string'
+            && value.exemption.reason.trim()
+            ? { status: 'platform_exempt', reason: value.exemption.reason }
+            : undefined;
+    if (exemption === undefined
+        || (value.kind === 'platform') !== (exemption !== null)
+        || (value.kind === 'platform') !== (value.certification === 'not_applicable')) {
+        throw new Error(`${label} has an invalid platform exemption`);
+    }
+    return {
+        targetId: value.targetId,
+        kind: value.kind,
+        implementation: value.implementation,
+        exemption,
+        suite: { version: value.suite.version, caseCount: Number(value.suite.caseCount) },
+        build: value.build,
+        exactArtifact: value.exactArtifact,
+        certification: value.certification,
+        dimensions,
+        parityGaps: value.parityGaps,
+        deploymentConflicts: value.deploymentConflicts,
+        knownBlockers: value.knownBlockers,
+    };
+}
+function validArtifact(value) {
+    return isRecord(value)
+        && typeof value.imageDigest === 'string'
+        && /^sha256:[a-f0-9]{64}$/.test(value.imageDigest)
+        && typeof value.sourceCommit === 'string'
+        && /^[a-f0-9]{40}$/.test(value.sourceCommit)
+        && typeof value.runtimeProfileHash === 'string'
+        && /^[a-f0-9]{64}$/.test(value.runtimeProfileHash);
+}
+function parseDimension(value, label) {
+    if (!isRecord(value)
+        || !EVIDENCE_STATUSES.has(value.status)
+        || ![value.passed, value.failed, value.total].every(item => Number.isSafeInteger(item) && Number(item) >= 0)
+        || Number(value.passed) + Number(value.failed) !== Number(value.total)
+        || !stringArray(value.caseIds)
+        || !stringArray(value.evidenceRefs)
+        || (value.score !== null && (typeof value.score !== 'number' || value.score < 0 || value.score > 1))) {
+        throw new Error(`${label} evidence is invalid`);
+    }
+    return value;
+}
+function renderDimension(dimension) {
+    if (dimension.status === 'not_run')
+        return 'not-run';
+    if (dimension.status === 'not_applicable')
+        return 'n/a';
+    return `${dimension.passed}/${dimension.total}`;
+}
+function canonicalTimestamp(value) {
+    if (typeof value !== 'string')
+        return false;
+    const parsed = new Date(value);
+    return Number.isFinite(parsed.getTime()) && parsed.toISOString() === value;
+}
+function stringArray(value) {
+    return Array.isArray(value) && value.every(item => typeof item === 'string');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=portfolio.js.map

package/dist/runtime.js

@@ -0,0 +1,165 @@
+const FIELD_KINDS = new Set([
+    'text',
+    'url',
+    'code',
+    'number',
+    'boolean',
+    'json',
+]);
+const QUALIFICATION_STATUSES = new Set([
+    'certified',
+    'blocked',
+    'stale',
+    'unqualified',
+]);
+const IMAGE_DIGEST = /^sha256:[a-f0-9]{64}$/;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNonemptySingleLine(value) {
+    return (typeof value === 'string'
+        && value.trim().length > 0
+        && !/[\u0000-\u001f\u007f]/u.test(value));
+}
+function isOptionalString(value, key) {
+    return value[key] === undefined || typeof value[key] === 'string';
+}
+function isOptionalNullableString(value, key) {
+    return (value[key] === undefined
+        || value[key] === null
+        || typeof value[key] === 'string');
+}
+function isPublishedField(value) {
+    if (!isRecord(value))
+        return false;
+    if (!isNonemptySingleLine(value.moduleName)
+        || !isNonemptySingleLine(value.name)
+        || !isNonemptySingleLine(value.label)
+        || typeof value.description !== 'string'
+        || typeof value.group !== 'string'
+        || !FIELD_KINDS.has(value.kind)
+        || (value.language !== null
+            && typeof value.language !== 'string')
+        || typeof value.available !== 'boolean') {
+        return false;
+    }
+    return !value.available || Object.hasOwn(value, 'value');
+}
+function isPublishedModule(value) {
+    return (isRecord(value)
+        && isNonemptySingleLine(value.moduleName)
+        && Array.isArray(value.fields)
+        && value.fields.every(isPublishedField));
+}
+function isQualification(value) {
+    if (!isRecord(value)
+        || value.schemaVersion !== 1
+        || !isNonemptySingleLine(value.id)
+        || !isNonemptySingleLine(value.cloneId)
+        || typeof value.score !== 'number'
+        || !Number.isFinite(value.score)
+        || value.score < 0
+        || value.score > 100
+        || !QUALIFICATION_STATUSES.has(value.status)
+        || typeof value.certified !== 'boolean'
+        || typeof value.imageDigest !== 'string'
+        || !IMAGE_DIGEST.test(value.imageDigest)
+        || !isNonemptySingleLine(value.verifiedAt)
+        || !Number.isFinite(new Date(value.verifiedAt).getTime())
+        || !isNonemptySingleLine(value.staleAt)
+        || !Number.isFinite(new Date(value.staleAt).getTime())
+        || !isRecord(value.categoryScores)) {
+        return false;
+    }
+    return Object.values(value.categoryScores).every(score => (typeof score === 'number'
+        && Number.isFinite(score)
+        && score >= 0
+        && score <= 100));
+}
+function isCloneRuntime(value) {
+    if (!isRecord(value))
+        return false;
+    const hasRuntimeState = (typeof value.provisioned === 'boolean'
+        || typeof value.status === 'string'
+        || typeof value.cloneStatus === 'string');
+    if (!hasRuntimeState
+        || (value.provisioned !== undefined
+            && typeof value.provisioned !== 'boolean')
+        || !isOptionalNullableString(value, 'zergId')
+        || !isOptionalString(value, 'status')
+        || !isOptionalString(value, 'cloneStatus')
+        || !isOptionalString(value, 'deployPhase')
+        || !isOptionalNullableString(value, 'serviceUrl')
+        || !isOptionalNullableString(value, 'socketUrl')
+        || !isOptionalNullableString(value, 'mirrorUrl')
+        || !isOptionalNullableString(value, 'errorMessage')
+        || !isOptionalNullableString(value, 'zergCloudUrl')
+        || !isOptionalNullableString(value, 'zstackRunUrl')
+        || !isOptionalNullableString(value, 'flyAppName')
+        || !isOptionalNullableString(value, 'flyAppUrl')
+        || !isOptionalNullableString(value, 'updatedAt')) {
+        return false;
+    }
+    const publicationKeys = [
+        'publicationStatus',
+        'publishedModules',
+        'publicationError',
+    ];
+    const publicationFieldCount = publicationKeys.filter(key => value[key] !== undefined).length;
+    if (publicationFieldCount !== 0 && publicationFieldCount !== publicationKeys.length) {
+        return false;
+    }
+    if (publicationFieldCount !== 0
+        && (!['ready', 'none', 'unavailable'].includes(String(value.publicationStatus))
+            || !Array.isArray(value.publishedModules)
+            || !value.publishedModules.every(isPublishedModule)
+            || (value.publicationError !== null
+                && typeof value.publicationError !== 'string'))) {
+        return false;
+    }
+    return (value.qualification === undefined
+        || value.qualification === null
+        || isQualification(value.qualification));
+}
+function isCloneCredential(value) {
+    if (!isRecord(value)
+        || value.schemaVersion !== 1
+        || !isNonemptySingleLine(value.vendor)
+        || !isRecord(value.authentication)
+        || value.authentication.type !== 'token'
+        || !isNonemptySingleLine(value.authentication.header)
+        || !isNonemptySingleLine(value.authentication.token)
+        || !isCredentialScheme(value.authentication.scheme, value.authentication.header)) {
+        return false;
+    }
+    if (value.login === undefined)
+        return true;
+    return (isRecord(value.login)
+        && isNonemptySingleLine(value.login.username)
+        && isNonemptySingleLine(value.login.path));
+}
+function isCredentialScheme(value, header) {
+    if (typeof value !== 'string'
+        || value !== value.trim()
+        || value.length > 64
+        || /[\u0000-\u001f\u007f]/u.test(value))
+        return false;
+    if (value === '') {
+        return (typeof header === 'string'
+            && header.toLowerCase() !== 'authorization');
+    }
+    return /^[A-Za-z][A-Za-z0-9._~-]*$/.test(value);
+}
+export function parseCloneRuntime(value, source) {
+    if (!isCloneRuntime(value)) {
+        throw new Error(`${source} returned an invalid runtime schema.`);
+    }
+    return value;
+}
+export function parseCloneCredential(value, source) {
+    if (!isCloneCredential(value)) {
+        throw new Error(`${source} returned an invalid credential schema.`);
+    }
+    return value;
+}
+//# sourceMappingURL=runtime.js.map

package/dist/vendors.js

@@ -0,0 +1,65 @@
+/**
+ * Per-vendor smoke checks — hit each clone the way its real SOC API/SDK would,
+ * to prove the vendor surface responds. zlunk + zokta are fully implemented;
+ * every other vendor falls back to /health + /metrics.
+ */
+import { hit } from './client.js';
+async function health(h) {
+    const r = await h('GET', '/health');
+    const vendor = r.json ?? {};
+    return { name: 'GET /health', ok: r.status === 200 && vendor.status === 'up', detail: `${r.status} ${vendor.vendor ?? ''}`.trim() };
+}
+const arr = (v) => (Array.isArray(v) ? v : null);
+export const VENDOR_SMOKE = {
+    zlunk: {
+        evokes: 'Splunk',
+        smoke: async (h) => {
+            const out = [await health(h)];
+            const s = await h('POST', '/services/search/jobs/export', {
+                headers: { Authorization: 'Splunk simtoken', 'Content-Type': 'application/x-www-form-urlencoded' },
+                // index=main holds the demo seed's HEC events; the mock doesn't expand index=*.
+                body: `search=${encodeURIComponent('search index=main')}&output_mode=json`,
+            });
+            const body = s.json;
+            const results = arr(body?.results) ?? arr(s.json);
+            out.push({
+                name: 'POST /services/search/jobs/export (SPL search)',
+                ok: s.status === 200 && Array.isArray(results),
+                detail: `${s.status}, ${results ? `${results.length} events` : 'no results'}`,
+            });
+            return out;
+        },
+    },
+    zokta: {
+        evokes: 'Okta',
+        smoke: async (h) => {
+            const out = [await health(h)];
+            const u = await h('GET', '/api/v1/users', { headers: { Authorization: 'SSWS ssws-simtoken' } });
+            out.push({ name: 'GET /api/v1/users', ok: u.status === 200 && !!arr(u.json), detail: `${u.status}, ${arr(u.json)?.length ?? '?'} users` });
+            const l = await h('GET', '/api/v1/logs?limit=100', { headers: { Authorization: 'SSWS ssws-simtoken' } });
+            out.push({ name: 'GET /api/v1/logs', ok: l.status === 200 && !!arr(l.json), detail: `${l.status}, ${arr(l.json)?.length ?? '?'} system-log events` });
+            return out;
+        },
+    },
+};
+function genericSpec(evokes) {
+    return {
+        evokes,
+        smoke: async (h) => {
+            const out = [await health(h)];
+            const m = await h('GET', '/metrics');
+            out.push({ name: 'GET /metrics', ok: m.status === 200, detail: `${m.status}` });
+            return out;
+        },
+    };
+}
+export function smokeFor(vendor, vendorEvokes = vendor) {
+    const spec = VENDOR_SMOKE[vendor] ?? genericSpec(vendorEvokes);
+    return spec.evokes === vendorEvokes ? spec : { ...spec, evokes: vendorEvokes };
+}
+/** Build a base-bound hit for a clone's public service URL. */
+export function boundHit(cloneBaseUrl) {
+    const base = cloneBaseUrl.replace(/\/+$/, '');
+    return (method, path, opts) => hit(method, `${base}${path}`, opts);
+}
+//# sourceMappingURL=vendors.js.map

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@zergai/cyberdeck",
+  "version": "0.1.0-beta.1",
+  "description": "Command-line client for Zerg CyberDeck clone environments and server-side SDK conformance runs.",
+  "type": "module",
+  "bin": {
+    "zcd": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "README.md",
+    "LICENSE.md",
+    "COMMERCIAL-LICENSING.md",
+    "NOTICE",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "license": "SEE LICENSE IN LICENSE.md",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Epoch-ML/zerg.git",
+    "directory": "cybersim/packages/deck-cli"
+  },
+  "homepage": "https://github.com/Epoch-ML/zerg/tree/development/cybersim/packages/deck-cli",
+  "bugs": {
+    "url": "https://github.com/Epoch-ML/zerg/issues"
+  },
+  "keywords": [
+    "zerg",
+    "cyberdeck",
+    "cybersecurity",
+    "sdk-conformance",
+    "cli"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "next"
+  },
+  "scripts": {
+    "build": "tsc --build --force",
+    "clean": "tsc --build --clean",
+    "prepack": "npm run clean && npm run build",
+    "test:public-tarball": "node scripts/smoke-packed-public-api.mjs"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "socket.io-client": "^4.8.1"
+  }
+}