@agents-at-scale/ark 0.1.47 → 0.1.49

package/.arkrc.template.yaml

@@ -0,0 +1,51 @@
+# Ark CLI Configuration Template
+# Copy this to ~/.arkrc.yaml (user config) or .arkrc.yaml (project config)
+# All fields are optional - only include what you want to override
+
+# Chat configuration
+chat:
+  # Enable/disable streaming for chat responses (default: true)
+  # streaming: true
+
+  # Output format: 'text' or 'markdown' (default: text)
+  # outputFormat: text
+
+# Service configuration
+services:
+  # Reuse existing kubectl port-forward processes instead of failing (default: false)
+  # reusePortForwards: false
+
+  # Service overrides - customize specific Ark services
+  # Example: Enable localhost-gateway
+  # localhost-gateway:
+  #   enabled: true
+
+  # Example: Change namespace
+  # ark-controller:
+  #   namespace: custom-namespace
+
+  # Example: Add custom install arguments
+  # ark-api:
+  #   installArgs:
+  #     - --set
+  #     - replicas=3
+
+  # Example: Configure Agents @ Scale with container registry
+  # agents-at-scale:
+  #   enabled: true
+  #   installArgs:
+  #     - --set
+  #     - containerRegistry.enabled=true
+  #     - --set
+  #     - containerRegistry.username=YOUR_USERNAME
+  #     - --set
+  #     - containerRegistry.password=YOUR_PASSWORD
+
+# Available service properties:
+#   enabled: boolean           - Enable/disable service installation
+#   namespace: string          - Kubernetes namespace
+#   chartPath: string          - Custom Helm chart path
+#   installArgs: string[]      - Additional Helm install arguments
+#   k8sServiceName: string     - Kubernetes service name for port forwarding
+#   k8sServicePort: number     - Kubernetes service port for port forwarding
+#   k8sPortForwardLocalPort: number - Local port for port forwarding

package/README.md

@@ -46,6 +46,8 @@ To troubleshoot an installation, run `ark status`.
 
 You can customize Ark service installations using a `.arkrc.yaml` file in your home directory (`~/.arkrc.yaml`) or project directory. This allows you to override service properties like enabled status, namespace, or chart location.
 
+See [`.arkrc.template.yaml`](.arkrc.template.yaml) for a complete reference of all available configuration options.
+
 Example `.arkrc.yaml`:
 
 ```yaml

package/dist/arkServices.js

@@ -119,17 +119,17 @@ const defaultArkServices = {
         k8sDeploymentName: 'ark-mcp',
         k8sDevDeploymentName: 'ark-mcp-devspace',
     },
-    'ark-cluster-memory': {
-        name: 'ark-cluster-memory',
-        helmReleaseName: 'ark-cluster-memory',
+    'ark-broker': {
+        name: 'ark-broker',
+        helmReleaseName: 'ark-broker',
         description: 'In-memory storage service with streaming support for Ark queries',
         enabled: true,
         category: 'service',
         // namespace: undefined - uses current context namespace
-        chartPath: `${REGISTRY_BASE}/ark-cluster-memory`,
+        chartPath: `${REGISTRY_BASE}/ark-broker`,
         installArgs: [],
-        k8sDeploymentName: 'ark-cluster-memory',
-        k8sDevDeploymentName: 'ark-cluster-memory-devspace',
+        k8sDeploymentName: 'ark-broker',
+        k8sDevDeploymentName: 'ark-broker-devspace',
     },
     'mcp-filesystem': {
         name: 'mcp-filesystem',
@@ -171,7 +171,9 @@ function applyConfigOverrides(defaults) {
     const overrides = config?.services || {};
     const result = {};
     for (const [key, service] of Object.entries(defaults)) {
-        result[key] = overrides[key] ? { ...service, ...overrides[key] } : service;
+        const override = overrides[key];
+        result[key] =
+            override && typeof override === 'object' ? { ...service, ...override } : service;
     }
     return result;
 }

package/dist/commands/chat/index.js

@@ -14,7 +14,7 @@ export function createChatCommand(config) {
         const initialTargetId = targetArg;
         // Config is passed from main
         try {
-            const proxy = new ArkApiProxy();
+            const proxy = new ArkApiProxy(undefined, config.services?.reusePortForwards ?? false);
             const arkApiClient = await proxy.start();
             render(_jsx(ChatUI, { initialTargetId: initialTargetId, arkApiClient: arkApiClient, arkApiProxy: proxy, config: config }));
         }

package/dist/commands/completion/index.js

@@ -28,7 +28,7 @@ _ark_completion() {
   
   case \${COMP_CWORD} in
     1)
-      opts="agents chat cluster completion config dashboard docs generate install marketplace models queries query routes status targets teams tools uninstall help"
+      opts="agents chat cluster completion config dashboard docs evaluation export generate import install marketplace memory models queries query routes status targets teams tools uninstall help"
       COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
       return 0
       ;;
@@ -84,6 +84,11 @@ _ark_completion() {
           COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
           return 0
           ;;
+        memory)
+          opts="list ls delete reset"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
         install)
           opts="marketplace/services/phoenix marketplace/services/langfuse marketplace/agents/noah"
           COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
@@ -155,9 +160,13 @@ _ark() {
         'config[Configuration management]' \\
         'dashboard[Open ARK dashboard]' \\
         'docs[Open ARK documentation]' \\
+        'evaluation[Execute evaluations against evaluators]' \\
+        'export[Export ARK resources to a file]' \\
         'generate[Generate ARK resources]' \\
+        'import[Import ARK resources from a file]' \\
         'install[Install ARK services]' \\
         'marketplace[Manage marketplace services]' \\
+        'memory[Manage memory sessions and queries]' \\
         'models[List available models]' \\
         'queries[Manage query resources]' \\
         'query[Execute a single query]' \\
@@ -225,6 +234,13 @@ _ark() {
             'list[List available marketplace services]' \\
             'ls[List available marketplace services]'
           ;;
+        memory)
+          _values 'memory commands' \\
+            'list[List all sessions]' \\
+            'ls[List all sessions]' \\
+            'delete[Delete memory data]' \\
+            'reset[Delete memory data]'
+          ;;
         install)
           _values 'services to install' \\
             'marketplace/services/phoenix[Phoenix observability platform]' \\

package/dist/commands/dashboard/index.d.ts

@@ -1,4 +1,4 @@
 import { Command } from 'commander';
 import type { ArkConfig } from '../../lib/config.js';
-export declare function openDashboard(): Promise<void>;
-export declare function createDashboardCommand(_: ArkConfig): Command;
+export declare function openDashboard(config: ArkConfig): Promise<void>;
+export declare function createDashboardCommand(config: ArkConfig): Command;

package/dist/commands/dashboard/index.js

@@ -4,11 +4,12 @@ import open from 'open';
 import ora from 'ora';
 import { ArkServiceProxy } from '../../lib/arkServiceProxy.js';
 import { arkServices } from '../../arkServices.js';
-export async function openDashboard() {
+export async function openDashboard(config) {
     const spinner = ora('Connecting to dashboard').start();
     try {
         const dashboardService = arkServices['ark-dashboard'];
-        const proxy = new ArkServiceProxy(dashboardService, 3274); // DASH on phone keypad
+        const proxy = new ArkServiceProxy(dashboardService, 3274, // DASH on phone keypad
+        config.services?.reusePortForwards ?? false);
         const url = await proxy.start();
         spinner.succeed('Dashboard connected');
         console.log(`ARK dashboard running on: ${chalk.green(url)}`);
@@ -30,10 +31,10 @@ export async function openDashboard() {
         process.exit(1);
     }
 }
-export function createDashboardCommand(_) {
+export function createDashboardCommand(config) {
     const dashboardCommand = new Command('dashboard');
     dashboardCommand
         .description('Open the ARK dashboard in your browser')
-        .action(openDashboard);
+        .action(() => openDashboard(config));
     return dashboardCommand;
 }

package/dist/commands/export/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { ArkConfig } from '../../lib/config.js';
+export declare function createExportCommand(config: ArkConfig): Command;

package/dist/commands/export/index.js

@@ -0,0 +1,73 @@
+import { Command } from 'commander';
+import * as fs from 'fs/promises';
+import yaml from 'yaml';
+import { listResources } from '../../lib/kubectl.js';
+import output from '../../lib/output.js';
+// resource types in dependency order so that they can be loaded correctly
+// by default these will all be exported if not specified; can be overridden with defaultExportTypes in config
+const RESOURCE_ORDER = [
+    'secrets',
+    'tools',
+    'models',
+    'agents',
+    'teams',
+    'evaluators',
+    'mcpservers',
+    'a2aservers',
+];
+async function exportResources(options, config) {
+    try {
+        const allResourceTypes = config.defaultExportTypes || RESOURCE_ORDER;
+        const outputPath = options.output || 'ark-export.yaml';
+        let resourceTypes = options.types
+            ? (options.types.split(','))
+            : allResourceTypes;
+        // ensure that we get resources in the correct order; e.g. agents before teams that use the agents
+        resourceTypes.sort((a, b) => {
+            return RESOURCE_ORDER.indexOf(a) - RESOURCE_ORDER.indexOf(b);
+        });
+        output.info(`exporting ark resources to ${outputPath}...`);
+        const allResources = [];
+        let allResourceCount = 0;
+        for (const resourceType of resourceTypes) {
+            if (!RESOURCE_ORDER.includes(resourceType)) {
+                output.warning(`unknown resource type: ${resourceType}, skipping`);
+                continue;
+            }
+            output.info(`fetching ${resourceType}...`);
+            const resources = await listResources(resourceType, {
+                namespace: options.namespace,
+                labels: options.labels
+            });
+            const resourceCount = resources.length;
+            if (resources.length > 0) {
+                output.success(`found ${resourceCount} ${resourceType}`);
+                allResources.push(...resources);
+                allResourceCount += resourceCount;
+            }
+        }
+        if (allResourceCount === 0) {
+            output.warning('no resources found to export');
+            return;
+        }
+        const yamlContent = allResources.map((resource) => yaml.stringify(resource)).join("\n---\n");
+        await fs.writeFile(outputPath, yamlContent, 'utf-8');
+        output.success(`exported ${allResourceCount} resources to ${outputPath}`);
+    }
+    catch (error) {
+        output.error('export failed:', error instanceof Error ? error.message : error);
+    }
+}
+export function createExportCommand(config) {
+    const exportCommand = new Command('export');
+    exportCommand
+        .description('export ARK resources to a file')
+        .option('-o, --output <file>', 'output file path', 'ark-export.yaml')
+        .option('-n, --namespace <namespace>', 'namespace to export from')
+        .option('-t, --types <types>', 'comma-separated list of resource types to export')
+        .option('-l, --labels <labels>', 'label selector to filter resources')
+        .action(async (options) => {
+        await exportResources(options, config);
+    });
+    return exportCommand;
+}

package/dist/commands/export/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/export/index.spec.js

@@ -0,0 +1,145 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const mockWriteFile = jest.fn();
+jest.unstable_mockModule('fs/promises', () => ({
+    writeFile: mockWriteFile,
+}));
+const mockOutput = {
+    info: jest.fn(),
+    success: jest.fn(),
+    warning: jest.fn(),
+    error: jest.fn(),
+};
+jest.unstable_mockModule('../../lib/output.js', () => ({
+    default: mockOutput,
+}));
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
+    throw new Error('process.exit called');
+}));
+const mockKubectlGetResponse = {
+    "apiVersion": "v1",
+    "items": [{ "spec": "foo" }],
+    "kind": "List",
+    "metadata": {
+        "resourceVersion": ""
+    }
+};
+const { createExportCommand } = await import('./index.js');
+describe('export command', () => {
+    const mockConfig = {};
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should create export command with correct description', () => {
+        const command = createExportCommand(mockConfig);
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('export');
+        expect(command.description()).toBe('export ARK resources to a file');
+    });
+    it('should export all resource types by default', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockKubectlGetResponse),
+        });
+        mockWriteFile.mockResolvedValue(undefined);
+        const command = createExportCommand(mockConfig);
+        await command.parseAsync(['node', 'test', '-o', 'test.yaml']);
+        const expectedResourceTypes = [
+            'secrets',
+            'tools',
+            'models',
+            'agents',
+            'teams',
+            'evaluators',
+            'mcpservers',
+            'a2aservers',
+        ];
+        expect(mockExeca).toHaveBeenCalledTimes(expectedResourceTypes.length);
+        for (const resourceType of expectedResourceTypes) {
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', expect.arrayContaining(['get', resourceType, '-o', 'json']), expect.any(Object));
+            expect(mockOutput.success).toHaveBeenCalledWith(`found 1 ${resourceType}`);
+        }
+        expect(mockWriteFile).toHaveBeenCalledTimes(1);
+    });
+    it('should export types specified in config in dependency order', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockKubectlGetResponse),
+        });
+        mockWriteFile.mockResolvedValue(undefined);
+        const newDefaultTypes = ['teams', 'agents'];
+        const modifiedConfig = { defaultExportTypes: newDefaultTypes };
+        const command = createExportCommand(modifiedConfig);
+        await command.parseAsync(['node', 'test', '-o', 'test.yaml']);
+        expect(mockExeca.mock.calls).toEqual([
+            ['kubectl', expect.arrayContaining(['get', 'agents']), expect.any(Object)],
+            ['kubectl', expect.arrayContaining(['get', 'teams']), expect.any(Object)],
+        ]);
+        expect(mockWriteFile).toHaveBeenCalledTimes(1);
+    });
+    it('should filter by resource types when specified and export in order', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockKubectlGetResponse),
+        });
+        mockWriteFile.mockResolvedValue(undefined);
+        const command = createExportCommand(mockConfig);
+        await command.parseAsync([
+            'node',
+            'test',
+            '-t',
+            'agents,models',
+            '-o',
+            'test.yaml',
+        ]);
+        expect(mockExeca.mock.calls).toEqual([
+            ['kubectl', expect.arrayContaining(['get', 'models']), expect.any(Object)],
+            ['kubectl', expect.arrayContaining(['get', 'agents']), expect.any(Object)],
+        ]);
+    });
+    it('should use namespace filter when specified', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockKubectlGetResponse),
+        });
+        mockWriteFile.mockResolvedValue(undefined);
+        const command = createExportCommand(mockConfig);
+        await command.parseAsync([
+            'node',
+            'test',
+            '-n',
+            'custom-namespace',
+            '-t',
+            'agents',
+            '-o',
+            'test.yaml',
+        ]);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', expect.arrayContaining(['-n', 'custom-namespace']), expect.any(Object));
+        expect(mockWriteFile).toHaveBeenCalledTimes(1);
+    });
+    it('should use label selector when specified', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockKubectlGetResponse),
+        });
+        mockWriteFile.mockResolvedValue(undefined);
+        const command = createExportCommand(mockConfig);
+        await command.parseAsync([
+            'node',
+            'test',
+            '-l',
+            'app=test',
+            '-t',
+            'agents',
+            '-o',
+            'test.yaml',
+        ]);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', expect.arrayContaining(['-l', 'app=test']), expect.any(Object));
+        expect(mockWriteFile).toHaveBeenCalledTimes(1);
+    });
+    it('fails if kubectl get fails for a resource type', async () => {
+        mockExeca.mockRejectedValue('Export broke');
+        const command = createExportCommand(mockConfig);
+        await command.parseAsync(['node', 'test']);
+        expect(mockOutput.error).toHaveBeenCalledWith('export failed:', 'Export broke');
+    });
+});

package/dist/commands/import/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { ArkConfig } from '../../lib/config.js';
+export declare function createImportCommand(_: ArkConfig): Command;

package/dist/commands/import/index.js

@@ -0,0 +1,27 @@
+import { Command } from 'commander';
+import { execa } from 'execa';
+import output from '../../lib/output.js';
+async function importResources(filepath) {
+    try {
+        output.info(`importing ark resources from ${filepath}...`);
+        const args = ['create', '-f', filepath];
+        const result = await execa('kubectl', args, {
+            stdio: 'pipe',
+        });
+        output.success(`imported resources from ${filepath}`);
+    }
+    catch (error) {
+        output.error('import failed:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+export function createImportCommand(_) {
+    const importCommand = new Command('import');
+    importCommand
+        .description('import ARK resources from a file')
+        .argument('<filepath>', 'input file path')
+        .action(async (filepath) => {
+        await importResources(filepath);
+    });
+    return importCommand;
+}

package/dist/commands/import/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/import/index.spec.js

@@ -0,0 +1,46 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const mockOutput = {
+    info: jest.fn(),
+    success: jest.fn(),
+    warning: jest.fn(),
+    error: jest.fn(),
+};
+jest.unstable_mockModule('../../lib/output.js', () => ({
+    default: mockOutput,
+}));
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
+    throw new Error('process.exit called');
+}));
+const { createImportCommand } = await import('./index.js');
+describe('import command', () => {
+    const mockConfig = {};
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should create import command with correct description', () => {
+        const command = createImportCommand(mockConfig);
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('import');
+        expect(command.description()).toBe('import ARK resources from a file');
+    });
+    it('should use kubectl to import', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify({ items: [] }),
+        });
+        const command = createImportCommand(mockConfig);
+        await command.parseAsync(['node', 'test', 'test.yaml']);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['create', '-f', 'test.yaml'], expect.any(Object));
+    });
+    it('exits with error when kubectl create has error', async () => {
+        mockExeca.mockRejectedValue('Import broke');
+        const command = createImportCommand(mockConfig);
+        await expect(command.parseAsync(['node', 'test', 'test.yaml'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith('import failed:', 'Import broke');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+});

package/dist/commands/memory/index.js

@@ -1,9 +1,11 @@
 import { Command } from 'commander';
+import { loadConfig } from '../../lib/config.js';
 import output from '../../lib/output.js';
 import { ArkApiProxy } from '../../lib/arkApiProxy.js';
 export async function listSessions(options) {
     try {
-        const proxy = new ArkApiProxy();
+        const config = loadConfig();
+        const proxy = new ArkApiProxy(undefined, config.services?.reusePortForwards ?? false);
         const arkApiClient = await proxy.start();
         const sessions = await arkApiClient.getSessions();
         if (options.output === 'json') {
@@ -27,7 +29,8 @@ export async function listSessions(options) {
 }
 export async function deleteSession(sessionId, options) {
     try {
-        const proxy = new ArkApiProxy();
+        const config = loadConfig();
+        const proxy = new ArkApiProxy(undefined, config.services?.reusePortForwards ?? false);
         const arkApiClient = await proxy.start();
         const response = await arkApiClient.deleteSession(sessionId);
         if (options.output === 'json') {
@@ -44,7 +47,8 @@ export async function deleteSession(sessionId, options) {
 }
 export async function deleteQuery(sessionId, queryId, options) {
     try {
-        const proxy = new ArkApiProxy();
+        const config = loadConfig();
+        const proxy = new ArkApiProxy(undefined, config.services?.reusePortForwards ?? false);
         const arkApiClient = await proxy.start();
         const response = await arkApiClient.deleteQueryMessages(sessionId, queryId);
         if (options.output === 'json') {
@@ -61,7 +65,8 @@ export async function deleteQuery(sessionId, queryId, options) {
 }
 export async function deleteAll(options) {
     try {
-        const proxy = new ArkApiProxy();
+        const config = loadConfig();
+        const proxy = new ArkApiProxy(undefined, config.services?.reusePortForwards ?? false);
         const arkApiClient = await proxy.start();
         const response = await arkApiClient.deleteAllSessions();
         if (options.output === 'json') {

package/dist/commands/query/index.js

@@ -11,6 +11,7 @@ export function createQueryCommand(config) {
         .option('-o, --output <format>', 'Output format: yaml, json, name or events (shows structured event data)')
         .option('--timeout <timeout>', 'Query timeout (e.g., 30s, 5m, 1h)')
         .option('--session-id <sessionId>', 'Session ID to associate with the query for conversation continuity')
+        .option('--conversation-id <conversationId>', 'Conversation ID to associate with the query for memory continuity')
         .action(async (target, message, options) => {
         const parsed = parseTarget(target);
         if (!parsed) {
@@ -24,6 +25,7 @@ export function createQueryCommand(config) {
             outputFormat: options.output,
             timeout: options.timeout || config.queryTimeout,
             sessionId: options.sessionId,
+            conversationId: options.conversationId,
         });
     });
     return queryCommand;

package/dist/index.js

@@ -14,7 +14,9 @@ import { createCompletionCommand } from './commands/completion/index.js';
 import { createDashboardCommand } from './commands/dashboard/index.js';
 import { createDocsCommand } from './commands/docs/index.js';
 import { createEvaluationCommand } from './commands/evaluation/index.js';
+import { createExportCommand } from './commands/export/index.js';
 import { createGenerateCommand } from './commands/generate/index.js';
+import { createImportCommand } from './commands/import/index.js';
 import { createInstallCommand } from './commands/install/index.js';
 import { createMarketplaceCommand } from './commands/marketplace/index.js';
 import { createMemoryCommand } from './commands/memory/index.js';
@@ -48,7 +50,9 @@ async function main() {
     program.addCommand(createDashboardCommand(config));
     program.addCommand(createDocsCommand(config));
     program.addCommand(createEvaluationCommand(config));
+    program.addCommand(createExportCommand(config));
     program.addCommand(createGenerateCommand(config));
+    program.addCommand(createImportCommand(config));
     program.addCommand(createInstallCommand(config));
     program.addCommand(createMarketplaceCommand(config));
     program.addCommand(createMemoryCommand(config));

package/dist/lib/arkApiProxy.d.ts

@@ -1,7 +1,7 @@
 import { ArkApiClient } from './arkApiClient.js';
 export declare class ArkApiProxy {
     private serviceProxy;
-    constructor(localPort?: number);
+    constructor(localPort?: number, reusePortForwards?: boolean);
     start(): Promise<ArkApiClient>;
     stop(): void;
     isRunning(): boolean;

package/dist/lib/arkApiProxy.js

@@ -2,9 +2,9 @@ import { ArkApiClient } from './arkApiClient.js';
 import { ArkServiceProxy } from './arkServiceProxy.js';
 import { arkServices } from '../arkServices.js';
 export class ArkApiProxy {
-    constructor(localPort) {
+    constructor(localPort, reusePortForwards = false) {
         const arkApiService = arkServices['ark-api'];
-        this.serviceProxy = new ArkServiceProxy(arkApiService, localPort);
+        this.serviceProxy = new ArkServiceProxy(arkApiService, localPort, reusePortForwards);
     }
     async start() {
         const arkApiUrl = await this.serviceProxy.start();

package/dist/lib/arkServiceProxy.d.ts

@@ -1,11 +1,13 @@
 import { ArkService } from '../arkServices.js';
 export declare class ArkServiceProxy {
+    private reusePortForwards;
     private kubectlProcess?;
     private localPort;
     private isReady;
     private service;
-    constructor(service: ArkService, localPort?: number);
+    constructor(service: ArkService, localPort?: number, reusePortForwards?: boolean);
     private getRandomPort;
+    private checkExistingPortForward;
     start(): Promise<string>;
     stop(): void;
     isRunning(): boolean;