vigthoria-cli 1.13.26 → 1.13.30

package/dist/commands/preview.js

@@ -81,7 +81,7 @@ export class PreviewCommand {
         // Run Template Service preview proof gate
         if (isPreviewProofRequested(options)) {
             try {
-                await this.runProofGate(projectPath, options.screenshot);
+                await this.runProofGate(projectPath, options.screenshot, options.screenshot === true && options.proof !== true);
             }
             catch (error) {
                 this.api.destroy();
@@ -435,7 +435,7 @@ export class PreviewCommand {
     /**
      * Run Template Service preview gate and persist proof bundle
      */
-    async runProofGate(projectPath, captureScreenshot) {
+    async runProofGate(projectPath, captureScreenshot, localScreenshotProof = false) {
         const spinner = createSpinner('Running preview proof gate...').start();
         try {
             const result = await this.api.runTemplateServicePreviewGate('', {
@@ -444,6 +444,11 @@ export class PreviewCommand {
                 targetPath: projectPath,
                 forceFrontendPreview: true,
                 requireScreenshot: captureScreenshot === true,
+                // An explicit screenshot-only command is a local operation. Do not
+                // upload the user's frontend or require an ecosystem login merely to
+                // capture local visual evidence. `--proof` retains the hosted proof
+                // contract, including when combined with `--screenshot`.
+                localScreenshotProof,
             });
             spinner.stop();
             console.log(chalk.bold.white(`  ${CH.hLine.repeat(3)} Preview Proof Gate ${CH.hLine.repeat(39)}`));

package/dist/commands/product-run-registration.js

@@ -386,7 +386,7 @@ Examples:
         .option('--no-open', 'Do not auto-open browser')
         .option('--diff', 'Show consolidated diff of recent agent changes')
         .option('--proof', 'Run Template Service preview gate and persist proof bundle')
-        .option('--screenshot', 'Capture screenshot via Puppeteer')
+        .option('--screenshot', 'Capture screenshot via an installed system browser')
         .action(async (options) => {
         const preview = new PreviewCommand(config, logger);
         await preview.run({

package/dist/commands/replay.d.ts

@@ -10,7 +10,6 @@ export declare class ReplayCommand {
     constructor(config: Config, _logger: Logger);
     private getHeaders;
     private getBaseUrl;
-    private resolveWorkspaceRoot;
     private sleep;
     run(runId: string, options: ReplayOptions): Promise<void>;
 }

package/dist/commands/replay.js

@@ -3,10 +3,10 @@ import { hasLocalV3AgentCapability } from '../utils/runtime-capability.js';
  * replay.ts — Replay events from a V3 agent run step-by-step.
  */
 import chalk from 'chalk';
-import { createRequire } from 'node:module';
 import { createSpinner, CH } from '../utils/logger.js';
 import { CliCommandError, commandFailure, formatSuccessJson } from '../utils/command-contract.js';
-const require = createRequire(import.meta.url);
+import { buildLocalWorkspaceReference } from '../utils/workspace-reference.js';
+import { guardedFetch } from '../utils/network-policy.js';
 export class ReplayCommand {
     config;
     constructor(config, _logger) {
@@ -34,33 +34,24 @@ export class ReplayCommand {
             (allowLocal ? 'http://127.0.0.1:8030' : null) ||
             configuredApiUrl);
     }
-    resolveWorkspaceRoot(project) {
-        if (/^[a-zA-Z]:[\\/]/.test(project) || /^\\\\/.test(project))
-            return '';
-        if (typeof require !== 'undefined') {
-            try {
-                const path = require('path');
-                if (!path.isAbsolute(project))
-                    return '';
-            }
-            catch { }
-        }
-        return project;
-    }
     sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
     async run(runId, options) {
         const speed = options.speed || 200;
         const project = options.project || process.cwd();
-        const workspace = this.resolveWorkspaceRoot(project);
+        const workspaceRef = buildLocalWorkspaceReference(project, String(this.config.get('userId') || this.config.get('email') || ''));
         const spinner = createSpinner(`Loading events for run ${runId}...`).start();
         try {
             const baseUrl = this.getBaseUrl();
-            const params = new URLSearchParams({ workspace_root: workspace });
-            const resp = await fetch(`${baseUrl}/api/runs/${encodeURIComponent(runId)}/events?${params}`, {
-                headers: this.getHeaders(),
+            const params = new URLSearchParams({
+                workspace_root: '',
+                local_workspace_path: workspaceRef,
+                project_path: workspaceRef,
             });
+            const resp = await guardedFetch(`${baseUrl}/api/runs/${encodeURIComponent(runId)}/events?${params}`, {
+                headers: this.getHeaders(),
+            }, { audience: 'v3' });
             if (!resp.ok) {
                 spinner.stop();
                 if (resp.status === 404) {

package/dist/commands/repo.js

@@ -161,6 +161,9 @@ export class RepoCommand {
         };
         try {
             const proxyResponse = await attempt(proxyPath, 'coder');
+            if (options.terminalStatuses?.includes(proxyResponse.status)) {
+                return proxyResponse;
+            }
             // A large repository payload can exceed the Coder API's general
             // 50 MiB parser while remaining valid under Community's 100 MiB
             // repository contract. Retry that one status directly.
@@ -615,7 +618,7 @@ export class RepoCommand {
             if (fs.existsSync(outputPath))
                 validateExtractedWorkspace(outputPath);
             if (isCompleteRepositoryInlinePayload(data)) {
-                const stagingRoot = createRuntimeTempDirectory('repo-inline-');
+                const stagingRoot = createRuntimeTempDirectory('repo-inline-', 128 * 1024 * 1024);
                 try {
                     let totalBytes = 0;
                     for (const file of data.files) {
@@ -650,7 +653,7 @@ export class RepoCommand {
                     throw new Error('Failed to download project archive');
                 const archiveBuffer = Buffer.from(await archiveResponse.arrayBuffer());
                 inspectZipArchive(archiveBuffer);
-                const stagingRoot = createRuntimeTempDirectory('repo-pull-');
+                const stagingRoot = createRuntimeTempDirectory('repo-pull-', 256 * 1024 * 1024);
                 const tempArchive = path.join(stagingRoot, 'archive.zip');
                 const extractedPath = path.join(stagingRoot, 'extracted');
                 try {
@@ -920,11 +923,20 @@ export class RepoCommand {
         const spinner = createSpinner('Deleting project...').start();
         try {
             const operationId = createOperationId();
-            const repo = await this.resolveRepoByName(projectName);
+            // A numeric canonical ID is safe to retry directly even after the
+            // first deletion removed it from the active repository listing.
+            const repo = /^\d+$/.test(projectName.trim())
+                ? { id: projectName.trim() }
+                : await this.resolveRepoByName(projectName);
             const response = await this.repoFetch(`/api/repo/projects/${encodeURIComponent(String(repo.id))}`, {
                 method: 'DELETE',
                 headers: { 'X-Vigthoria-Operation-Id': operationId },
-            }, { operationId });
+            }, { operationId, terminalStatuses: /^\d+$/.test(projectName.trim()) ? [404] : undefined });
+            if (response.status === 404 && /^\d+$/.test(projectName.trim())) {
+                spinner.succeed(chalk.green('Project was already deleted from Vigthoria Community Repository'));
+                console.log(chalk.gray('\nNote: Your local files are not affected.\n'));
+                return;
+            }
             if (!response.ok) {
                 const error = await response.json();
                 throw new Error(error.error || 'Failed to delete project');

package/dist/commands/update-registration.js

@@ -186,7 +186,7 @@ export function registerUpdateCommand(program, version) {
                 let updateTempDirectory = null;
                 try {
                     if (source.kind === 'remote') {
-                        updateTempDirectory = createRuntimeTempDirectory('update-');
+                        updateTempDirectory = createRuntimeTempDirectory('update-', 320 * 1024 * 1024);
                         installTarget = path.join(updateTempDirectory, 'candidate.tgz');
                         await downloadFile(source.downloadUrl, installTarget);
                     }
@@ -304,7 +304,7 @@ export function registerUpdateCommand(program, version) {
             && compareVersions(manifestEntry.version, currentVersion) > 0);
         if (manifestIsAuthoritative && manifestEntry) {
             assertReleaseTransition(currentVersion, manifestEntry, channel, allowDowngrade);
-            const updateTempDirectory = createRuntimeTempDirectory('update-');
+            const updateTempDirectory = createRuntimeTempDirectory('update-', 320 * 1024 * 1024);
             const tmpFile = path.join(updateTempDirectory, 'candidate.tgz');
             try {
                 console.log(chalk.cyan(`Downloading release package (${manifestEntry.version})...`));

package/dist/commands/workflow.d.ts

@@ -19,6 +19,9 @@ interface WorkflowRunOptions extends WorkflowOutputOptions {
 interface WorkflowStatusOptions extends WorkflowOutputOptions {
     brain?: boolean;
 }
+interface WorkflowDeleteOptions extends WorkflowOutputOptions {
+    yes?: boolean;
+}
 export declare class WorkflowCommand {
     private config;
     private logger;
@@ -35,6 +38,7 @@ export declare class WorkflowCommand {
     useTemplate(templateId: string, options: WorkflowUseOptions): Promise<void>;
     run(workflowId: string, options: WorkflowRunOptions): Promise<void>;
     status(executionId: string, options: WorkflowStatusOptions): Promise<void>;
+    delete(selector: string, options: WorkflowDeleteOptions): Promise<void>;
 }
 export declare function registerWorkflowCommands(program: Command, config: Config, logger: Logger): void;
 export {};

package/dist/commands/workflow.js

@@ -190,6 +190,29 @@ export class WorkflowCommand {
             `Completed: ${execution.completedAt || '-'}`,
         ].join('\n'), 'Workflow Status');
     }
+    async delete(selector, options) {
+        this.ensureAuthenticated();
+        if (options.yes !== true) {
+            throw new CliCommandError('Workflow deletion requires explicit confirmation with --yes.', {
+                code: 'WORKFLOW_DELETE_CONFIRMATION_REQUIRED',
+                category: 'usage',
+            });
+        }
+        let deleted;
+        try {
+            deleted = await this.api.deleteVigFlowWorkflow(selector);
+        }
+        catch (error) {
+            throw commandFailure(error, { code: 'WORKFLOW_DELETE_FAILED' });
+        }
+        if (options.json) {
+            this.printJson('workflow delete', { deleted });
+            return;
+        }
+        this.logger.success(deleted.alreadyDeleted
+            ? `Workflow ${deleted.id} was already deleted.`
+            : `Workflow ${deleted.name || deleted.id} deleted.`);
+    }
 }
 export function registerWorkflowCommands(program, config, logger) {
     const workflowCommand = program.command('workflow').alias('flow')
@@ -215,5 +238,9 @@ export function registerWorkflowCommands(program, config, logger) {
         .option('--no-brain', 'Do not remember this workflow status in local Project Brain')
         .option('--json', 'Emit machine-readable JSON output', false)
         .action(async (executionId, options) => new WorkflowCommand(config, logger).status(executionId, options));
+    workflowCommand.command('delete <workflowIdOrName>').alias('rm').description('Delete an owned workflow (idempotent by workflow ID)')
+        .option('--yes', 'Confirm permanent workflow deletion', false)
+        .option('--json', 'Emit machine-readable JSON output', false)
+        .action(async (selector, options) => new WorkflowCommand(config, logger).delete(selector, options));
     workflowCommand.action(async () => new WorkflowCommand(config, logger).templates({}));
 }

package/dist/index.js

@@ -29,6 +29,7 @@ import { registerWorkflowCommands } from './commands/workflow.js';
 import { LegionCommand } from './commands/legion.js';
 import { WalletCommand } from './commands/wallet.js';
 import { registerV4Commands } from './commands/v4-registration.js';
+import { registerCreativeCommands } from './commands/creative-registration.js';
 import { Config } from './utils/config.js';
 import { Logger, CH } from './utils/logger.js';
 import chalk from 'chalk';
@@ -51,6 +52,7 @@ import { installConsoleRedaction } from './utils/secret-policy.js';
 import { commandNameFromArgv, failureEnvelope, normalizeCommandError, CliCommandError, } from './utils/command-contract.js';
 import { commandAuthRequirement, commanderCommandPath } from './utils/command-policy.js';
 import { initializeRuntimeTempStorage } from './utils/runtime-temp.js';
+import { hasLocalV3ServiceIdentity } from './utils/runtime-capability.js';
 initializeRuntimeTempStorage();
 applyLocalTestfarmDefaults();
 if (process.env.VIGTHORIA_CAPTURE_RUNTIME_MODEL !== '1')
@@ -418,6 +420,7 @@ export async function main(args) {
     registerPlatformCommands(program, config, logger);
     registerCodingCommands(program, config, logger);
     registerWorkflowCommands(program, config, logger);
+    registerCreativeCommands(program, config, logger);
     registerProductAndRunCommands(program, config, logger);
     // ==================== AUTH COMMANDS ====================
     // Auth commands
@@ -534,11 +537,12 @@ export async function main(args) {
         const authRequirement = commandAuthRequirement(commandPath);
         if (authRequirement === 'none')
             return;
-        // On-box service identities are authenticated by their destination
-        // service and must not be confused with a user gateway session.
-        const hasServiceKey = Boolean(process.env.HYPERLOOP_SERVICE_KEY || process.env.V3_SERVICE_KEY);
+        // A local V3 service identity is valid only for Agent. It must never
+        // bypass session policy for coding, repository, deploy, workflow, or any
+        // other command merely because a service key exists on this host.
+        const localAgentServiceIdentity = commandPath === 'agent' && hasLocalV3ServiceIdentity();
         const legionCortex = commandPath === 'legion' && actionCommand.opts().cortex === true;
-        if (hasServiceKey || legionCortex)
+        if (localAgentServiceIdentity || legionCortex)
             return;
         const explicitEnvToken = Boolean(process.env.VIGTHORIA_TOKEN || process.env.VIGTHORIA_AUTH_TOKEN);
         if (authRequirement === 'required-session' && !config.isAuthenticated() && !explicitEnvToken) {

package/dist/utils/agentRunOutcome.d.ts

@@ -37,6 +37,13 @@ export interface RunEvaluation {
     statusHeadline: string;
     uiTheme: 'success' | 'warning' | 'error';
 }
+/** Preserve mutation-journal truth while avoiding a false partial-mutation
+ * classification for a read-only run that changed no files. A failed or
+ * unknown rollback always wins over the observed final file count because a
+ * rollback can remove the changed-file snapshot while still leaving state
+ * uncertain on disk.
+ */
+export declare function resolveAgentPartialMutation(changedFileCount: number, reported: unknown): false | 'unknown';
 export declare function createLiveOutcome(): LiveOutcome;
 export declare function isExecutorTimeoutFailure(liveOutcome: LiveOutcome): boolean;
 export declare function isInferenceDegradedFailure(liveOutcome: LiveOutcome): boolean;

package/dist/utils/agentRunOutcome.js

@@ -2,6 +2,19 @@
  * Task-and-quality-validated success evaluation for V3 agent runs.
  * Decouples CLI verdict from raw file-change counts (1.11.0+).
  */
+/** Preserve mutation-journal truth while avoiding a false partial-mutation
+ * classification for a read-only run that changed no files. A failed or
+ * unknown rollback always wins over the observed final file count because a
+ * rollback can remove the changed-file snapshot while still leaving state
+ * uncertain on disk.
+ */
+export function resolveAgentPartialMutation(changedFileCount, reported) {
+    if (reported === true || reported === 'unknown')
+        return 'unknown';
+    if (reported === false)
+        return false;
+    return changedFileCount > 0 ? 'unknown' : false;
+}
 export function createLiveOutcome() {
     return {
         executorFailed: false,

package/dist/utils/api.d.ts

@@ -30,6 +30,17 @@ export type ChatRequestOptions = {
 export interface APIClientDependencies {
     screenshotAdapter?: PreviewScreenshotPort;
 }
+type V3ClientToolMutation = {
+    path: string;
+    content: string;
+    sha256: string;
+};
+type V3ClientToolResult = {
+    success: boolean;
+    output: string;
+    error?: string;
+    mutation?: V3ClientToolMutation;
+};
 export declare class CLIError extends Error {
     category: CLIErrorCategory;
     statusCode?: number;
@@ -167,6 +178,11 @@ export declare class APIClient {
         executionOptions?: Record<string, unknown>;
     }): Promise<VigFlowExecutionResult>;
     getVigFlowExecutionStatus(executionId: string): Promise<VigFlowExecutionStatus>;
+    deleteVigFlowWorkflow(selector: string): Promise<{
+        id: string;
+        name?: string;
+        alreadyDeleted?: boolean;
+    }>;
     getV3AgentHeaders(): Promise<Record<string, string>>;
     ensureV3ServiceKey(): Promise<void>;
     runV3HealthCheck(): Promise<{
@@ -229,12 +245,15 @@ export declare class APIClient {
     captureV3AgentStreamMutation(event: any, streamedFiles: Record<string, string>, serverRoot?: string | null): void;
     private applyV3AgentStreamEventToWorkspace;
     private resolveV3ClientToolPath;
+    private describeMissingV3ClientToolPath;
     private recordV3ClientToolMutation;
+    private buildV3ClientToolMutation;
     private executeV3ClientToolRequest;
     private handleV3ClientToolRequest;
     private writeV3AgentWorkspaceFile;
     recoverAgentWorkspaceFiles(context?: Record<string, any>, streamedFiles?: Record<string, string>, expectedFiles?: string[]): void;
     normalizeAgentWorkspaceRelativePath(rawPath: string, rootPath?: string): string;
+    private isExplicitSingleFileFrontendRequest;
     ensureAgentFrontendPolish(message?: string, context?: Record<string, any>): Promise<void>;
     private injectSectionBeforeFooter;
     private injectNavLink;
@@ -342,11 +361,7 @@ export declare class APIClient {
     getClientToolErrors(): string[];
     clearAgentRunDiagnostics(): void;
     private recordClientToolError;
-    submitClientToolResult(contextId: string, callId: string, result: {
-        success: boolean;
-        output: string;
-        error?: string;
-    }, backendUrl?: string | null): Promise<void>;
+    submitClientToolResult(contextId: string, callId: string, result: V3ClientToolResult, backendUrl?: string | null): Promise<void>;
     private isHealthyServicePayload;
     private extractModelCount;
     private probeModelList;