@halot/cli 1.0.0

package/dist/features/provider/provider-register.command.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProviderRegisterCommand = runProviderRegisterCommand;
+const ethers_1 = require("ethers");
+const actor_headers_service_1 = require("@halot/cli/shared/auth/actor-headers.service");
+const api_client_1 = require("@halot/cli/shared/http/api-client");
+const agent_id_register_service_1 = require("@halot/cli/shared/integrations/agent-id/agent-id-register.service");
+const space_id_register_service_1 = require("@halot/cli/shared/integrations/space-id/space-id-register.service");
+const print_util_1 = require("@halot/cli/shared/output/print.util");
+const authority_util_1 = require("@halot/cli/shared/wallet/authority.util");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runProviderRegisterCommand(options) {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const api = new api_client_1.ApiClient(options.server);
+    const config = workspace.readProviderConfig();
+    const wallets = workspace.readWallets(config.authority.path);
+    const providerWallet = (0, authority_util_1.resolveActorWallet)(wallets, config.authority.actor);
+    const chain = (0, authority_util_1.resolveZeroGAuthorityProfile)(config.authority.actor);
+    const isMainnet = (0, authority_util_1.isMainnetAuthority)(config.authority.actor);
+    if (isMainnet) {
+        const domainRegistrationService = new space_id_register_service_1.SpaceIdRegisterService();
+        const domainResult = await domainRegistrationService.registerZeroGDomain({
+            domain: config.identity.domain,
+            address: providerWallet.address,
+            privateKey: providerWallet.privateKey,
+            chainId: chain.chainId,
+            rpcUrl: chain.rpcUrl,
+        });
+        console.log(`Registered ${domainResult.domain}${domainResult.transactionHash ? ` (${domainResult.transactionHash})` : ''}`);
+    }
+    else {
+        console.log(`Skipping Space ID domain registration (testnet mode)`);
+    }
+    let provider = await api.post('/providers/register', {
+        config: {
+            ...config,
+            identity: {
+                ...config.identity,
+                ownerAddress: providerWallet.address,
+            },
+        },
+        ownerAddress: providerWallet.address,
+    });
+    if (isMainnet) {
+        const agentIdRegisterService = new agent_id_register_service_1.AgentIdRegisterService();
+        const agentUri = (0, agent_id_register_service_1.createZeroGAgentUri)(provider.rootHash);
+        const agentResult = await agentIdRegisterService.registerAgent({
+            ownerAddress: providerWallet.address,
+            privateKey: providerWallet.privateKey,
+            chainId: chain.chainId,
+            rpcUrl: chain.rpcUrl,
+            agentUri,
+        });
+        const path = `/providers/${provider.providerId}/identity`;
+        const headers = await (0, actor_headers_service_1.createSignedActorHeaders)(new ethers_1.Wallet(providerWallet.privateKey), provider.providerId, 'provider', 'POST', path);
+        provider = await api.post(path, {
+            erc8004TokenId: agentResult.agentId,
+            agentRegistry: agentResult.agentRegistry,
+            agentUri: agentResult.agentUri,
+        }, headers);
+        console.log(`Registered Agent ID ${agentResult.agentId}${agentResult.transactionHash ? ` (${agentResult.transactionHash})` : ''}`);
+    }
+    workspace.writeProviderConfig({
+        ...config,
+        providerId: provider.providerId,
+        identity: provider.identity,
+    });
+    (0, print_util_1.printJson)(provider);
+    console.log('\nProvider registered.');
+    console.log('Next: halot service init');
+    console.log('Then: halot service register');
+}

package/dist/features/provider/provider-run.command.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProviderRunCommand = runProviderRunCommand;
+exports.requireExecutionEndpoint = requireExecutionEndpoint;
+const sdk_1 = require("@halot/sdk");
+const actor_headers_service_1 = require("@halot/cli/shared/auth/actor-headers.service");
+const api_client_1 = require("@halot/cli/shared/http/api-client");
+const event_stream_1 = require("@halot/cli/shared/http/event-stream");
+const print_util_1 = require("@halot/cli/shared/output/print.util");
+const authority_util_1 = require("@halot/cli/shared/wallet/authority.util");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runProviderRunCommand(options) {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const api = new api_client_1.ApiClient(options.server);
+    const config = workspace.readProviderConfig();
+    const wallets = workspace.readWallets(config.authority.path);
+    const providerWallet = (0, authority_util_1.resolveActorWallet)(wallets, config.authority.actor);
+    const intervalMs = Number(options.interval);
+    const workerId = (0, sdk_1.createPrefixedId)('worker');
+    const cursorKey = `provider:${config.providerId}`;
+    let lastEventId = workspace.readStreamCursor(cursorKey);
+    if (options.once) {
+        const assignmentPath = `/providers/${config.providerId}/jobs/next`;
+        const headers = await (0, actor_headers_service_1.createSignedActorHeaders)(providerWallet, config.providerId, 'provider', 'GET', assignmentPath);
+        const assignment = await api.get(assignmentPath, headers);
+        if (!assignment) {
+            console.log('No provider assignments available.');
+            return;
+        }
+        await processProviderAssignment(api, providerWallet, config.providerId, assignment);
+        return;
+    }
+    do {
+        try {
+            const streamPath = `/providers/${config.providerId}/jobs/stream`;
+            const headers = {
+                ...(await (0, actor_headers_service_1.createSignedActorHeaders)(providerWallet, config.providerId, 'provider', 'GET', streamPath)),
+                'x-halot-worker-id': workerId,
+            };
+            for await (const event of (0, event_stream_1.connectEventStream)(`${options.server}${streamPath}`, headers, lastEventId)) {
+                if (event.event === 'checkpoint') {
+                    if (event.id) {
+                        lastEventId = event.id;
+                        workspace.writeStreamCursor(cursorKey, event.id);
+                    }
+                    continue;
+                }
+                if (event.event !== 'assignment') {
+                    continue;
+                }
+                const assignment = JSON.parse(event.data);
+                await processProviderAssignment(api, providerWallet, config.providerId, assignment);
+                if (event.id) {
+                    lastEventId = event.id;
+                    workspace.writeStreamCursor(cursorKey, event.id);
+                }
+            }
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            await (0, print_util_1.sleep)(intervalMs);
+        }
+    } while (true);
+}
+function requireExecutionEndpoint(endpoint, serviceId) {
+    const executionEndpoint = endpoint?.trim();
+    if (!executionEndpoint) {
+        throw new Error(`Service ${serviceId} is missing \`endpoint.execution\`. Configure it on the service or use SDK middleware instead.`);
+    }
+    return executionEndpoint;
+}
+async function executeProviderJob(endpoint, assignment) {
+    const timeoutMs = assignment.service.sla.maxExecutionTime * 1_000;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+        response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                jobId: assignment.job.jobId,
+                jobHash: assignment.job.jobHash,
+                serviceId: assignment.service.serviceId,
+                input: assignment.job.input,
+                service: assignment.service,
+            }),
+            signal: controller.signal,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error(`Provider execution timed out after ${assignment.service.sla.maxExecutionTime}s.`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+    if (!response.ok) {
+        throw new Error(`Provider execution request failed with status ${response.status}.`);
+    }
+    const body = await response.json();
+    return body.output ?? body;
+}
+function resolveExecutionAttempts(retryPolicy) {
+    const normalized = retryPolicy.trim().toLowerCase();
+    if (!normalized || normalized === 'none') {
+        return 1;
+    }
+    if (normalized === 'once') {
+        return 2;
+    }
+    if (normalized === 'twice') {
+        return 3;
+    }
+    const retriesMatch = normalized.match(/^(?:retry:|retries:)?(\d+)$/);
+    if (retriesMatch) {
+        return Math.max(1, Number(retriesMatch[1]) + 1);
+    }
+    return 1;
+}
+async function executeProviderJobWithRetry(endpoint, assignment) {
+    const attempts = resolveExecutionAttempts(assignment.service.sla.retryPolicy);
+    let lastError;
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+        try {
+            return await executeProviderJob(endpoint, assignment);
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < attempts) {
+                await (0, print_util_1.sleep)(250);
+            }
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+async function processProviderAssignment(api, providerWallet, providerId, assignment) {
+    const endpoint = requireExecutionEndpoint(assignment.service.endpoint?.execution, assignment.service.serviceId);
+    const output = await executeProviderJobWithRetry(endpoint, assignment);
+    const submitPath = `/jobs/${assignment.job.jobId}/result`;
+    const submitHeaders = await (0, actor_headers_service_1.createSignedActorHeaders)(providerWallet, providerId, 'provider', 'POST', submitPath);
+    const job = await api.post(submitPath, { output }, submitHeaders);
+    (0, print_util_1.printJson)(job);
+}

package/dist/features/provider/provider-services.command.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProviderServicesCommand = runProviderServicesCommand;
+const api_client_1 = require("@halot/cli/shared/http/api-client");
+const print_util_1 = require("@halot/cli/shared/output/print.util");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runProviderServicesCommand(options) {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const config = workspace.readProviderConfig();
+    const api = new api_client_1.ApiClient(options.server);
+    const services = await api.get(`/providers/${config.providerId}/services`);
+    (0, print_util_1.printJson)(services);
+}

package/dist/features/provider/provider-stats.command.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProviderStatsCommand = runProviderStatsCommand;
+const api_client_1 = require("@halot/cli/shared/http/api-client");
+const print_util_1 = require("@halot/cli/shared/output/print.util");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runProviderStatsCommand(options) {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const config = workspace.readProviderConfig();
+    const api = new api_client_1.ApiClient(options.server);
+    const stats = await api.get(`/providers/${config.providerId}/stats`);
+    (0, print_util_1.printJson)(stats);
+}

package/dist/features/provider/provider-update.command.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProviderUpdateCommand = runProviderUpdateCommand;
+const actor_headers_service_1 = require("@halot/cli/shared/auth/actor-headers.service");
+const api_client_1 = require("@halot/cli/shared/http/api-client");
+const print_util_1 = require("@halot/cli/shared/output/print.util");
+const authority_util_1 = require("@halot/cli/shared/wallet/authority.util");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runProviderUpdateCommand(options) {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const api = new api_client_1.ApiClient(options.server);
+    const config = workspace.readProviderConfig();
+    if (!config.providerId) {
+        throw new Error('Provider not registered. Run `halot provider register` first.');
+    }
+    const wallets = workspace.readWallets(config.authority.path);
+    const providerWallet = (0, authority_util_1.resolveActorWallet)(wallets, config.authority.actor);
+    const path = `/providers/${config.providerId}`;
+    const headers = await (0, actor_headers_service_1.createSignedActorHeaders)(providerWallet, config.providerId, 'provider', 'PUT', path);
+    const provider = await api.put(path, {
+        displayName: config.displayName,
+        description: config.description,
+        version: config.version,
+        settlementWallets: config.settlementWallets,
+    }, headers);
+    workspace.writeProviderConfig({
+        ...config,
+        displayName: provider.displayName,
+        description: provider.description,
+        version: provider.version,
+        settlementWallets: provider.settlementWallets,
+    });
+    console.log(`Updated provider ${provider.providerId}`);
+    (0, print_util_1.printJson)(provider);
+}

package/dist/features/quotes/quote.command.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runQuoteCommand = runQuoteCommand;
+const api_client_1 = require("@halot/cli/shared/http/api-client");
+const print_util_1 = require("@halot/cli/shared/output/print.util");
+async function runQuoteCommand(options) {
+    const api = new api_client_1.ApiClient(options.server);
+    const quote = await api.post('/quote', {
+        serviceId: options.service,
+        input: JSON.parse(options.input),
+    });
+    (0, print_util_1.printJson)(quote);
+}

package/dist/features/requester/requester-init.command.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRequesterInitCommand = runRequesterInitCommand;
+const wallet_manager_1 = require("@halot/cli/shared/wallet/wallet.manager");
+const authority_util_1 = require("@halot/cli/shared/wallet/authority.util");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runRequesterInitCommand() {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const walletManager = new wallet_manager_1.WalletManager(workspace);
+    const wallets = walletManager.createWallets();
+    workspace.writeRequesterConfig({
+        requesterId: '',
+        displayName: 'Halot Requester',
+        authority: {
+            path: './wallets.json',
+            actor: '0g:testnet',
+        },
+    });
+    console.log('Requester workspace initialized.');
+    console.log(`0G testnet authority: ${(0, authority_util_1.resolveAuthorityAddress)(wallets, '0g:testnet')}`);
+    console.log(`Stellar testnet authority: ${(0, authority_util_1.resolveAuthorityAddress)(wallets, 'stellar:testnet')}`);
+}

package/dist/features/service/service-create.command.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runServiceCreateCommand = void 0;
+exports.runServiceRegisterCommand = runServiceRegisterCommand;
+const actor_headers_service_1 = require("@halot/cli/shared/auth/actor-headers.service");
+const api_client_1 = require("@halot/cli/shared/http/api-client");
+const print_util_1 = require("@halot/cli/shared/output/print.util");
+const authority_util_1 = require("@halot/cli/shared/wallet/authority.util");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runServiceRegisterCommand(options) {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const api = new api_client_1.ApiClient(options.server);
+    const config = workspace.readProviderConfig();
+    const wallets = workspace.readWallets(config.authority.path);
+    const providerWallet = (0, authority_util_1.resolveActorWallet)(wallets, config.authority.actor);
+    if (!config.providerId) {
+        throw new Error('Provider not registered. Run `halot provider register` first.');
+    }
+    const draft = resolveDraftService(workspace, options.file);
+    if (!draft) {
+        if (options.file) {
+            throw new Error(`Service file ${options.file} was not found.`);
+        }
+        throw new Error('No unregistered service drafts found. Run `halot service init` first.');
+    }
+    if (draft.service.serviceId.trim()) {
+        throw new Error(`Service file ${draft.fileName} is already registered as ${draft.service.serviceId}. Use \`halot service update\` to change it.`);
+    }
+    const path = `/providers/${config.providerId}/services`;
+    const headers = await (0, actor_headers_service_1.createSignedActorHeaders)(providerWallet, config.providerId, 'provider', 'POST', path);
+    const service = await api.post(path, draft.service, headers);
+    const canonicalFileName = `service-${service.serviceId}.json`;
+    workspace.replaceServiceFile(draft.fileName, canonicalFileName, service);
+    console.log(`Registered service ${service.serviceId}`);
+    console.log(`Saved services/${canonicalFileName}`);
+    (0, print_util_1.printJson)(service);
+}
+exports.runServiceCreateCommand = runServiceRegisterCommand;
+function resolveDraftService(workspace, fileName) {
+    if (fileName) {
+        const knownFiles = workspace.listServiceFiles();
+        if (!knownFiles.includes(fileName)) {
+            return undefined;
+        }
+        return {
+            fileName,
+            service: workspace.readServiceFile(fileName),
+        };
+    }
+    for (const candidate of workspace.listServiceFiles()) {
+        const service = workspace.readServiceFile(candidate);
+        if (!service.serviceId.trim()) {
+            return { fileName: candidate, service };
+        }
+    }
+    return undefined;
+}

package/dist/features/service/service-init.command.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runServiceInitCommand = runServiceInitCommand;
+const sdk_1 = require("@halot/sdk");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runServiceInitCommand(options) {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const fileName = workspace.nextServiceDraftFileName();
+    const name = options.name?.trim() || 'New Service';
+    const category = parseServiceCategory(options.category);
+    const trustLevel = parseTrustLevel(options.trustLevel);
+    const description = options.description?.trim() || `Description for ${name}`;
+    const service = {
+        serviceId: '',
+        name,
+        description,
+        version: '1.0.0',
+        category,
+        trustLevel,
+        endpoint: {
+            health: 'https://your-provider.example/health',
+            execution: 'https://your-provider.example/execute',
+        },
+        pricing: {
+            baseFee: '3.00',
+            currency: 'USDC',
+            model: 'per-job',
+        },
+        settlement: {
+            accepts: [
+                { network: '0g:testnet', token: 'USDC' },
+                { network: 'stellar:testnet', token: 'USDC' },
+            ],
+        },
+        input: {
+            schema: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', maxLength: 500 },
+                    depth: { type: 'string', enum: ['brief', 'detailed'] },
+                },
+                required: ['query'],
+            },
+            maxSize: '10kb',
+        },
+        output: {
+            schema: {
+                type: 'object',
+                properties: {
+                    title: { type: 'string' },
+                    summary: { type: 'string' },
+                    sections: { type: 'array' },
+                    sources: { type: 'array' },
+                },
+                required: ['title', 'summary', 'sections'],
+            },
+            format: 'json',
+        },
+        acceptanceCriteria: {
+            schemaValid: true,
+            minSections: 3,
+            sourcesRequired: true,
+        },
+        sla: {
+            maxExecutionTime: 120,
+            retryPolicy: 'none',
+        },
+    };
+    workspace.writeService(fileName, service);
+    console.log(`Created service draft services/${fileName}`);
+}
+function parseServiceCategory(value) {
+    if (!value) {
+        return 'text';
+    }
+    if (!sdk_1.serviceCategoryValues.includes(value)) {
+        throw new Error(`Unsupported service category "${value}". Expected one of: ${sdk_1.serviceCategoryValues.join(', ')}`);
+    }
+    return value;
+}
+function parseTrustLevel(value) {
+    if (!value) {
+        return 'standard';
+    }
+    if (!sdk_1.trustLevelValues.includes(value)) {
+        throw new Error(`Unsupported trust level "${value}". Expected one of: ${sdk_1.trustLevelValues.join(', ')}`);
+    }
+    return value;
+}

package/dist/features/service/service-list.command.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runServiceListCommand = runServiceListCommand;
+const api_client_1 = require("@halot/cli/shared/http/api-client");
+const print_util_1 = require("@halot/cli/shared/output/print.util");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runServiceListCommand(options) {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const api = new api_client_1.ApiClient(options.server);
+    const config = workspace.readProviderConfig();
+    if (!config.providerId) {
+        throw new Error('Provider not registered. Run `halot provider register` first.');
+    }
+    const services = await api.get(`/providers/${config.providerId}/services`);
+    if (services.length === 0) {
+        console.log('No services registered. Run `halot service init`, then `halot service register`.');
+        return;
+    }
+    for (const service of services) {
+        console.log(`${service.serviceId}  ${service.name}  $${service.pricing.baseFee} ${service.pricing.currency}  trust:${service.trustLevel}`);
+    }
+    (0, print_util_1.printJson)(services);
+}

package/dist/features/service/service-remove.command.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runServiceRemoveCommand = runServiceRemoveCommand;
+const actor_headers_service_1 = require("@halot/cli/shared/auth/actor-headers.service");
+const api_client_1 = require("@halot/cli/shared/http/api-client");
+const authority_util_1 = require("@halot/cli/shared/wallet/authority.util");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runServiceRemoveCommand(serviceId, options) {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const api = new api_client_1.ApiClient(options.server);
+    const config = workspace.readProviderConfig();
+    const wallets = workspace.readWallets(config.authority.path);
+    const providerWallet = (0, authority_util_1.resolveActorWallet)(wallets, config.authority.actor);
+    if (!config.providerId) {
+        throw new Error('Provider not registered. Run `halot provider register` first.');
+    }
+    const path = `/providers/${config.providerId}/services/${serviceId}`;
+    const headers = await (0, actor_headers_service_1.createSignedActorHeaders)(providerWallet, config.providerId, 'provider', 'DELETE', path);
+    await api.delete(path, headers);
+    console.log(`Removed service ${serviceId}`);
+}

package/dist/features/service/service-update.command.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runServiceUpdateCommand = runServiceUpdateCommand;
+const actor_headers_service_1 = require("@halot/cli/shared/auth/actor-headers.service");
+const api_client_1 = require("@halot/cli/shared/http/api-client");
+const print_util_1 = require("@halot/cli/shared/output/print.util");
+const authority_util_1 = require("@halot/cli/shared/wallet/authority.util");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runServiceUpdateCommand(serviceId, options) {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const api = new api_client_1.ApiClient(options.server);
+    const config = workspace.readProviderConfig();
+    const wallets = workspace.readWallets(config.authority.path);
+    const providerWallet = (0, authority_util_1.resolveActorWallet)(wallets, config.authority.actor);
+    if (!config.providerId) {
+        throw new Error('Provider not registered. Run `halot provider register` first.');
+    }
+    const draft = resolveRegisteredService(workspace, options.file, serviceId);
+    if (!draft) {
+        if (options.file) {
+            throw new Error(`Service file ${options.file} was not found.`);
+        }
+        if (serviceId) {
+            throw new Error(`Service ${serviceId} does not have a local service file.`);
+        }
+        throw new Error('No registered service files found. Run `halot service register` first.');
+    }
+    const resolvedServiceId = draft.service.serviceId.trim();
+    const path = `/providers/${config.providerId}/services/${resolvedServiceId}`;
+    const headers = await (0, actor_headers_service_1.createSignedActorHeaders)(providerWallet, config.providerId, 'provider', 'PUT', path);
+    const service = await api.put(path, draft.service, headers);
+    console.log(`Updated service ${service.serviceId}`);
+    workspace.writeService(`service-${service.serviceId}.json`, service);
+    (0, print_util_1.printJson)(service);
+}
+function resolveRegisteredService(workspace, fileName, serviceId) {
+    if (fileName) {
+        const knownFiles = workspace.listServiceFiles();
+        if (!knownFiles.includes(fileName)) {
+            return undefined;
+        }
+        return {
+            fileName,
+            service: workspace.readServiceFile(fileName),
+        };
+    }
+    if (serviceId) {
+        const inferredFile = `service-${serviceId}.json`;
+        const knownFiles = workspace.listServiceFiles();
+        if (!knownFiles.includes(inferredFile)) {
+            return undefined;
+        }
+        return {
+            fileName: inferredFile,
+            service: workspace.readServiceFile(inferredFile),
+        };
+    }
+    for (const candidate of workspace.listServiceFiles()) {
+        const service = workspace.readServiceFile(candidate);
+        if (service.serviceId.trim()) {
+            return { fileName: candidate, service };
+        }
+    }
+    return undefined;
+}

package/dist/features/verifier/verifier-init.command.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVerifierInitCommand = runVerifierInitCommand;
+const wallet_manager_1 = require("@halot/cli/shared/wallet/wallet.manager");
+const authority_util_1 = require("@halot/cli/shared/wallet/authority.util");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runVerifierInitCommand() {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const walletManager = new wallet_manager_1.WalletManager(workspace);
+    const wallets = walletManager.createWallets();
+    workspace.writeVerifierConfig({
+        verifierId: '',
+        displayName: 'My Verifier',
+        description: 'Multimodal service verification specialist',
+        identity: {
+            erc8004TokenId: '',
+            agentRegistry: '',
+            agentUri: '',
+            ownerAddress: (0, authority_util_1.resolveAuthorityAddress)(wallets, '0g:testnet'),
+            domain: 'myverifier.0g',
+            domainType: 'space-id',
+        },
+        authority: {
+            path: './wallets.json',
+            actor: '0g:testnet',
+        },
+        settlementWallets: (0, authority_util_1.createDefaultSettlementWallets)(wallets),
+        stake: {
+            amount: '1000',
+            token: '0G',
+            status: 'unlocked',
+        },
+        fees: {
+            computeBudgetPerJob: '0.50',
+        },
+    });
+    workspace.writeModelConfig({
+        evaluationModel: {
+            providerAddress: '',
+            serviceType: 'chatbot',
+            verifiability: 'TeeML',
+        },
+        sdk: {
+            network: 'testnet',
+        },
+        timeout: 60,
+    });
+    workspace.writeInferenceTemplate({
+        systemPrompt: 'You are an impartial evaluator.',
+        promptTemplate: 'Evaluate whether the provider result and any referenced artifacts satisfy the acceptance criteria.',
+        outputSchema: {
+            decision: 'approve | reject | uncertain',
+            confidence: 'number between 0 and 1',
+            reason: 'string',
+            failedCriteria: 'array',
+        },
+        maxTokens: 1024,
+        temperature: 0,
+    });
+    workspace.writeSpecializations({
+        categories: ['text', 'document', 'tool'],
+        serviceIds: [],
+        maxConcurrentJobs: 5,
+        minConfidenceThreshold: 0.75,
+    });
+    console.log('Verifier workspace initialized.');
+    console.log(`0G testnet authority: ${(0, authority_util_1.resolveAuthorityAddress)(wallets, '0g:testnet')}`);
+    console.log(`Stellar testnet authority: ${(0, authority_util_1.resolveAuthorityAddress)(wallets, 'stellar:testnet')}`);
+}