@playcraft/cli 0.1.40-beta → 0.1.41-prod

package/dist/commands/tools-image-context.js

@@ -0,0 +1,29 @@
+import { readImageAssetContext } from '../utils/image-asset-context.js';
+import { collectReferenceImagePaths, handleError, parseImageTargetFieldPath } from './tools-utils.js';
+export function registerImageContextCommand(tools) {
+    tools.command('image-context')
+        .description('Read image asset reference and delivery constraints locally; does not generate an image')
+        .requiredOption('--asset-path <path>', 'Existing image asset path relative to the project')
+        .option('--target-field-path <path>', 'Target image field as an array of keys, e.g. ["endUI","playButton"]', parseImageTargetFieldPath)
+        .option('--output-path <path>', 'Intended output path; checks shared asset protection before generation', collectReferenceImagePaths, [])
+        .option('--allowed-output-root <path>', 'Additional output directory authorized by the caller; does not allow external references', collectReferenceImagePaths, [])
+        .option('--reference-image <path>', 'Explicit local reference; may be repeated', collectReferenceImagePaths, [])
+        .option('--no-target-reference', 'Do not use the target schema or current asset as a reference')
+        .option('--prompt <text>', 'Generation request used to resolve background intent')
+        .option('--remove-background', 'Explicitly request verified transparency')
+        .option('--no-remove-background', 'Explicitly keep an opaque background')
+        .action(async (opts) => {
+        try {
+            console.log(JSON.stringify(await readImageAssetContext(opts.assetPath, process.cwd(), {
+                referenceImagePaths: opts.referenceImage, useTargetReference: opts.targetReference,
+                ...(opts.targetFieldPath ? { targetFieldPath: opts.targetFieldPath } : {}),
+                outputPaths: opts.outputPath,
+                allowedOutputRoots: opts.allowedOutputRoot,
+                prompt: opts.prompt, removeBackground: opts.removeBackground,
+            })));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}

package/dist/commands/tools-utils.js

@@ -1,8 +1,20 @@
 import { writeFileSync, mkdirSync, readFileSync } from 'fs';
 import { join, parse } from 'path';
 import { tmpdir } from 'os';
+import { InvalidArgumentError } from 'commander';
 export const TMP_DIR = join(tmpdir(), 'playcraft');
 export const MAX_REFERENCE_IMAGES = 8;
+export function parseImageTargetFieldPath(value) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch { /* Report the expected shape below. */ }
+    if (!Array.isArray(parsed) || !parsed.length || parsed.some(key => typeof key !== 'string' || !key.length)) {
+        throw new InvalidArgumentError('Expected an array of field names, e.g. ["endUI","playButton"].');
+    }
+    return parsed;
+}
 export function ensureTmpDir() {
     mkdirSync(TMP_DIR, { recursive: true });
 }

package/dist/commands/tools.js

@@ -1,16 +1,16 @@
 import { registerGenerationCommands } from './tools-generation.js';
-import { registerBatchCommands } from './tools-batch.js';
 import { registerProjectCommands } from './tools-project.js';
 import { register3DCommands } from './tools-3d.js';
 import { registerDetectCommand } from './tools-detect.js';
 import { registerVideoReviewCommand } from './tools-video-review.js';
+import { registerImageContextCommand } from './tools-image-context.js';
 export function registerToolsCommands(program) {
     const tools = program
         .command('tools')
         .description('后端 /api/agent/tools；运行 playcraft login 后即可直接使用，也支持 .playcraft.json 或 PLAYCRAFT_SANDBOX_TOKEN 环境变量');
     registerGenerationCommands(tools);
+    registerImageContextCommand(tools);
     registerProjectCommands(tools);
-    registerBatchCommands(tools);
     register3DCommands(tools);
     registerDetectCommand(tools);
     registerVideoReviewCommand(tools);

package/dist/config.js

@@ -2,8 +2,7 @@ import { cosmiconfig } from 'cosmiconfig';
 import { z } from 'zod';
 import path from 'path';
 import { homedir } from 'os';
-import { chmodSync, mkdirSync, renameSync, rmSync, writeFileSync, readFileSync } from 'fs';
-import { randomUUID } from 'node:crypto';
+import { mkdirSync, writeFileSync, readFileSync } from 'fs';
 import 'dotenv/config';
 export const ConfigSchema = z.object({
     projectId: z.string().optional(),
@@ -19,33 +18,6 @@ const explorer = cosmiconfig('playcraft', {
 });
 const GLOBAL_CONFIG_DIR = path.join(homedir(), '.playcraft');
 const GLOBAL_CONFIG_FILE = path.join(GLOBAL_CONFIG_DIR, 'config.json');
-export function normalizeEnvironmentBaseUrl(raw) {
-    try {
-        const url = new URL(raw);
-        if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password)
-            return undefined;
-        url.hash = '';
-        url.search = '';
-        url.pathname = url.pathname.replace(/\/+$/, '').replace(/\/api$/, '');
-        return url.toString().replace(/\/+$/, '');
-    }
-    catch {
-        return undefined;
-    }
-}
-export function readEnvironmentProfile(config, baseUrl) {
-    const key = normalizeEnvironmentBaseUrl(baseUrl);
-    const profiles = config.environmentProfiles;
-    if (!key || !profiles || typeof profiles !== 'object' || Array.isArray(profiles))
-        return undefined;
-    const profile = profiles[key];
-    if (!profile || typeof profile !== 'object' || Array.isArray(profile))
-        return undefined;
-    const value = profile;
-    if (typeof value.token !== 'string' || !value.token || normalizeEnvironmentBaseUrl(value.backendUrl) !== key)
-        return undefined;
-    return value;
-}
 export function loadGlobalConfig() {
     try {
         const content = readFileSync(GLOBAL_CONFIG_FILE, 'utf-8');
@@ -56,8 +28,7 @@ export function loadGlobalConfig() {
     }
 }
 export function saveGlobalConfig(partial) {
-    mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true, mode: 0o700 });
-    chmodSync(GLOBAL_CONFIG_DIR, 0o700);
+    mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
     let existing = {};
     try {
         existing = JSON.parse(readFileSync(GLOBAL_CONFIG_FILE, 'utf-8'));
@@ -66,25 +37,7 @@ export function saveGlobalConfig(partial) {
         // ignore
     }
     const merged = { ...existing, ...partial };
-    const temporary = path.join(GLOBAL_CONFIG_DIR, `.config-${randomUUID()}.tmp`);
-    try {
-        writeFileSync(temporary, JSON.stringify(merged, null, 2), { encoding: 'utf-8', flag: 'wx', mode: 0o600 });
-        renameSync(temporary, GLOBAL_CONFIG_FILE);
-    }
-    finally {
-        rmSync(temporary, { force: true });
-    }
-}
-export function saveEnvironmentProfile(baseUrl, profile) {
-    const key = normalizeEnvironmentBaseUrl(baseUrl);
-    if (!key)
-        throw new Error('Invalid environment address');
-    const current = loadGlobalConfig();
-    const profiles = current.environmentProfiles && typeof current.environmentProfiles === 'object'
-        && !Array.isArray(current.environmentProfiles) ? current.environmentProfiles : {};
-    saveGlobalConfig({ environmentProfiles: { ...profiles,
-            [key]: { ...profile, backendUrl: key, updatedAt: new Date().toISOString() } },
-        token: profile.token, url: key, backendUrl: key });
+    writeFileSync(GLOBAL_CONFIG_FILE, JSON.stringify(merged, null, 2), 'utf-8');
 }
 export async function loadConfig(cliOptions) {
     const result = await explorer.search(cliOptions.dir || process.cwd());
@@ -93,20 +46,12 @@ export async function loadConfig(cliOptions) {
         ? (fileConfig.agent || {})
         : fileConfig;
     const globalConfig = loadGlobalConfig();
-    const explicitTarget = cliOptions.url || process.env.PLAYCRAFT_URL || agentConfig.url;
-    const targetUrl = explicitTarget || globalConfig.url;
-    const profile = typeof targetUrl === 'string' ? readEnvironmentProfile(globalConfig, targetUrl) : undefined;
-    const legacyTarget = typeof globalConfig.backendUrl === 'string' ? globalConfig.backendUrl
-        : typeof globalConfig.url === 'string' ? globalConfig.url : undefined;
-    const legacyToken = !explicitTarget || (legacyTarget && normalizeEnvironmentBaseUrl(String(targetUrl)) === normalizeEnvironmentBaseUrl(legacyTarget))
-        ? globalConfig.token : undefined;
     const config = ConfigSchema.parse({
         ...globalConfig,
         ...agentConfig,
         ...cliOptions,
         projectId: cliOptions.projectId || process.env.PLAYCRAFT_PROJECT_ID || agentConfig.projectId || globalConfig.projectId,
-        url: targetUrl,
-        token: cliOptions.token || process.env.PLAYCRAFT_TOKEN || agentConfig.token || profile?.token || legacyToken,
+        token: cliOptions.token || process.env.PLAYCRAFT_TOKEN || agentConfig.token || globalConfig.token,
         port: cliOptions.port || (process.env.PLAYCRAFT_PORT ? parseInt(process.env.PLAYCRAFT_PORT) : undefined) || agentConfig.port || globalConfig.port,
         mode: cliOptions.mode || process.env.PLAYCRAFT_MODE || agentConfig.mode || globalConfig.mode,
         skillsDir: cliOptions.skillsDir || process.env.AGENT_SKILLS_DIR || agentConfig.skillsDir || globalConfig.skillsDir,

package/dist/index.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
-import { Command, CommanderError } from 'commander';
-import { accountActivationMessage } from './auth/messages.js';
+import { Command } from 'commander';
 import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
@@ -28,28 +27,16 @@ import { registerLevelsCommands } from './commands/levels.js';
 import { registerPatternsCommands } from './commands/patterns.js';
 import { registerPradCommands } from './commands/prad.js';
 import { register3DCommands } from './commands/3d.js';
-import { registerWorkspaceRuntimeCommands } from './commands/workspace-runtime.js';
-import { registerWorkspaceCommands } from './commands/workspace.js';
-import { registerVideoCommands } from './commands/video.js';
-import { registerPlayableCommands } from './commands/playable.js';
-import { videoMessage } from './video-replication/messages.js';
 import { CLI_ROOT_DESCRIPTION, getCliTopicsHelpText, registerRootProgramHelp, } from './cli-root-help.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const packageJson = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
 const program = new Command();
-const structuredVideoTopic = ['video', 'playable'].includes(process.argv[2] ?? '');
-const registryTopic = process.argv[2] === 'skills' && process.argv[3] === 'registry';
-if (structuredVideoTopic)
-    program.exitOverride();
 program.name('playcraft').description(CLI_ROOT_DESCRIPTION).version(packageJson.version);
-// Registry upload commands use --version for the skill, after the command name.
-if (registryTopic)
-    program.enablePositionalOptions();
 registerRootProgramHelp(program);
 // 版本检查（非阻塞，后台执行）
 // 只在非 upgrade 命令时检查，避免重复提示
-if (!structuredVideoTopic && !registryTopic && !process.argv.includes('upgrade') && !process.argv.includes('workspace-runtime')) {
+if (!process.argv.includes('upgrade')) {
     checkForUpdates(packageJson);
 }
 // create 命令
@@ -78,8 +65,6 @@ program
     .command('login')
     .description('登录 PlayCraft 账号并获取 CLI token')
     .option('--url <url>', 'Portal / API 基址（默认 https://playcraft.aix.intlgame.com，可用环境变量 PLAYCRAFT_URL 覆盖）')
-    .option('--activate', accountActivationMessage('activateOption'))
-    .option('--token <token>', accountActivationMessage('tokenOption'))
     .action(async (options) => {
     const { loginCommand } = await import('./commands/login.js');
     await loginCommand(options);
@@ -383,26 +368,4 @@ registerPatternsCommands(program);
 registerPradCommands(program);
 // 3D model utilities (playcraft 3d <command>)
 register3DCommands(program);
-registerWorkspaceRuntimeCommands(program);
-registerWorkspaceCommands(program);
-registerVideoCommands(program);
-registerPlayableCommands(program);
-if (structuredVideoTopic) {
-    try {
-        await program.parseAsync(process.argv);
-    }
-    catch (error) {
-        if (!(error instanceof CommanderError))
-            throw error;
-        if (error.exitCode === 0)
-            process.exitCode = 0;
-        else {
-            const command = [process.argv[2], process.argv[3]?.startsWith('-') ? undefined : process.argv[3]].filter(Boolean).join(' ');
-            process.stdout.write(`${JSON.stringify({ schemaVersion: 'playcraft.video-cli.v1', command, state: 'failed', ok: false,
-                error: { code: 'invalidArguments', message: videoMessage('invalidArguments') } })}\n`);
-            process.exitCode = 64;
-        }
-    }
-}
-else
-    program.parse(process.argv);
+program.parse(process.argv);

package/dist/remix/clone.js

@@ -1,4 +1,3 @@
-import { prepareLocalSkillLifecycle } from '../project-skills/lifecycle.js';
 import { spawnSync } from 'node:child_process';
 import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
 import path from 'node:path';
@@ -152,7 +151,6 @@ export async function remixClone(options) {
     };
     writePlaycraftMeta(targetDir, meta);
     configureRepoCredentialHelper(targetDir);
-    await prepareLocalSkillLifecycle(targetDir, 'checkout');
     let projectType;
     try {
         const project = await client.get(`/projects/${encodeURIComponent(projectId)}`);

package/dist/remix/init-template.js

@@ -1,4 +1,3 @@
-import { prepareLocalSkillLifecycle } from '../project-skills/lifecycle.js';
 import * as path from 'node:path';
 import { applyEnginePackToProject, bakeFullTemplate, KNOWN_ADAPTERS, readAdapterFromAtomTree, readEngineMarker, resolveCliPackageRoot, } from '../scaffold/compose.js';
 import { autoLinkSkillsFromAtomTree } from '../commands/skills.js';
@@ -69,7 +68,6 @@ export async function initTemplateCommand(opts) {
             console.log(`  ⚠ auto-link skipped: ${err.message}`);
         }
     }
-    await prepareLocalSkillLifecycle(projectDir, 'create');
     console.log('\n下一步：');
     console.log('  npm install');
     console.log('  阅读 .claude/skills/<atom>/SKILL.md（已自动 link）并填 logs/developer-log.md § Skill Preflight');

package/dist/remix/pull.js

@@ -1,4 +1,3 @@
-import { prepareLocalSkillLifecycle } from '../project-skills/lifecycle.js';
 import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
@@ -45,7 +44,6 @@ export async function remixPull(options = {}) {
         const detail = [result.stderr, result.stdout].filter(Boolean).join('\n').trim();
         throw new Error(detail || `git pull 失败（exit ${result.status}）`);
     }
-    await prepareLocalSkillLifecycle(repoDir, 'checkout');
     if (options.json) {
         console.log(JSON.stringify({
             schemaVersion: '1.0',

package/dist/remix/push.js

@@ -1,6 +1,3 @@
-import { prepareLocalSkillLifecycle } from '../project-skills/lifecycle.js';
-import { reconcileLocalProjectSkills } from '../project-skills/reconcile.js';
-import { projectSkillsMessage as skillMessage } from '../project-skills/messages.js';
 import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
@@ -44,7 +41,6 @@ export async function remixPush(options = {}) {
         process.stderr.write(`[push] ${meta.cloneUrl}\n`);
         process.stderr.write(`[push] branch=${meta.branch} dir=${repoDir}\n`);
     }
-    const skills = await prepareLocalSkillLifecycle(repoDir, 'push');
     const result = runAuthenticatedGit(['push', ...effectiveArgs], {
         cwd: repoDir,
         token: client.token,
@@ -54,24 +50,10 @@ export async function remixPush(options = {}) {
         const detail = [result.stderr, result.stdout].filter(Boolean).join('\n').trim();
         throw new Error(detail || `git push 失败（exit ${result.status}）`);
     }
-    let skillIndex;
-    let skillIndexFailed = false;
-    if (skills.managed) {
-        try {
-            skillIndex = await reconcileLocalProjectSkills(repoDir, { url: options.url, token: options.token });
-        }
-        catch (error) {
-            skillIndexFailed = true;
-            skillIndex = { indexed: false, message: skillMessage('pushIndexFailed'), detail: error instanceof Error ? error.message : String(error) };
-            process.exitCode = 1;
-        }
-        if (!options.json)
-            process.stderr.write(`${JSON.stringify(skillIndex)}\n`);
-    }
     if (options.json) {
         console.log(JSON.stringify({
             schemaVersion: '1.0',
-            ok: !skillIndexFailed,
+            ok: true,
             command: 'remix.push',
             requestId: client.requestId,
             data: {
@@ -80,8 +62,6 @@ export async function remixPush(options = {}) {
                 cloneUrl: meta.cloneUrl,
                 dir: repoDir,
                 gitArgs: effectiveArgs,
-                gitPushed: true,
-                skills: skillIndex,
             },
         }));
         return;

package/dist/utils/agent-api-client.js

@@ -1,12 +1,8 @@
 import { readFileSync, existsSync } from 'fs';
-import { dirname, join } from 'path';
+import { join } from 'path';
 import { homedir } from 'os';
 import { loadGlobalConfig } from '../config.js';
 import { DEFAULT_PLAYCRAFT_CLOUD_BASE } from '../commands/login.js';
-import { AGENT_TOOL_OPERATION_PROTOCOL, AGENT_TOOL_OPERATION_HEADERS, AGENT_TOOL_OPERATION_CAPABILITIES_PATH, } from '@playcraft/common/agent-tools';
-import { beginToolOperation } from './tool-operation-journal.js';
-import { businessEndpoint } from './environment-endpoints.js';
-import { AccountActivationError, parseErrorPayload, pendingAccountActivationError, } from '../auth/account-activation.js';
 /**
  * 判断 token 是否为用户 PAT（Personal Access Token）。
  * PAT 以 "playcraft_pat_" 开头；沙箱 JWT 为三段式 base64。
@@ -19,8 +15,8 @@ function isPatToken(token) {
  * or from the CLI after `playcraft login`.
  *
  * 凭证解析优先级：
- *   API URL : PLAYCRAFT_API_URL → sandbox global .playcraft.json → project .playcraft.json → ~/.playcraft/config.json → DEFAULT_PLAYCRAFT_CLOUD_BASE
- *   Token   : PLAYCRAFT_SANDBOX_TOKEN → sandbox global .playcraft.json → project .playcraft.json → ~/.playcraft/config.json token (PAT)
+ *   API URL : PLAYCRAFT_API_URL → .playcraft.json → ~/.playcraft/config.json → DEFAULT_PLAYCRAFT_CLOUD_BASE
+ *   Token   : PLAYCRAFT_SANDBOX_TOKEN → .playcraft.json token → ~/.playcraft/config.json token (PAT)
  *
  * 鉴权 header 自动选择：
  *   - 沙箱 JWT (非 PAT) → X-Sandbox-Token: <token>（后端 @SandboxToken 路由的沙箱分支）
@@ -29,7 +25,7 @@ function isPatToken(token) {
 export class AgentApiClient {
     apiUrl;
     token;
-    credentialFile;
+    isPat;
     playcraftEnv;
     constructor() {
         const localConfig = AgentApiClient.loadLocalConfig();
@@ -40,7 +36,7 @@ export class AgentApiClient {
             globalConfig.backendUrl ||
             globalConfig.url ||
             DEFAULT_PLAYCRAFT_CLOUD_BASE).replace(/\/+$/, '');
-        // Token: 环境变量 → 沙箱全局配置 → 项目配置 → 用户登录配置
+        // Token: 沙箱 token 环境变量 → 本地 .playcraft.json → 全局 login 配置（PAT）
         const token = process.env.PLAYCRAFT_SANDBOX_TOKEN ||
             localConfig.token ||
             globalConfig.token ||
@@ -51,147 +47,43 @@ export class AgentApiClient {
         }
         this.apiUrl = apiUrl;
         this.token = token;
-        this.credentialFile = localConfig.credentialFile;
-        this.playcraftEnv = (process.env.PLAYCRAFT_ENV || localConfig.env || '').trim();
+        this.isPat = isPatToken(token);
+        this.playcraftEnv = (process.env.PLAYCRAFT_ENV ||
+            localConfig.env ||
+            '').trim();
     }
     /** 根据 token 类型构造鉴权 headers */
     authHeaders() {
-        let token = this.token;
-        // Polling commands can outlive a credential: read the atomically refreshed file per request.
-        if (this.credentialFile && !process.env.PLAYCRAFT_SANDBOX_TOKEN) {
-            try {
-                token = JSON.parse(readFileSync(this.credentialFile, 'utf8')).token || token;
-            }
-            catch { /* Keep the last credential if a local file is temporarily unavailable. */ }
-        }
-        const headers = isPatToken(token)
-            ? { Authorization: `Bearer ${token}` }
-            : { 'X-Sandbox-Token': token };
+        const headers = this.isPat
+            ? { Authorization: `Bearer ${this.token}` }
+            : { 'X-Sandbox-Token': this.token };
         if (this.playcraftEnv) {
             headers['playcraft-env'] = this.playcraftEnv;
         }
         return headers;
     }
-    /** Deployment-relative pathname under /api/agent/tools (path may omit leading slash). */
+    /** Absolute pathname under /api/agent/tools (path may omit leading slash). */
     toolsRequestUrl(path) {
         const p = path.startsWith('/') ? path : `/${path}`;
-        return businessEndpoint(this.apiUrl, `/api/agent/tools${p}`);
+        return new URL(`/api/agent/tools${p}`, this.apiUrl);
     }
-    async post(path, body, options) {
-        const url = this.toolsRequestUrl(path);
-        const serializedBody = JSON.stringify(body);
-        if (serializedBody === undefined)
-            throw new Error('Tool request body is required');
-        const recoverId = options?.requestId ?? process.env.PLAYCRAFT_TOOL_REQUEST_ID;
-        const operation = beginToolOperation(url.pathname, serializedBody, recoverId, {
-            newRequest: options?.newRequest ?? process.env.PLAYCRAFT_TOOL_NEW_REQUEST === '1',
+    async post(path, body) {
+        const url = this.toolsRequestUrl(path).href;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.authHeaders(),
+            },
+            body: JSON.stringify(body),
         });
-        const unknownOutcome = `Tool request ${operation.requestId}: the outcome is unknown. Rerun the same command to ` +
-            `continue this request: it returns the result if the request finished, or finishes it if ` +
-            `the tool can be safely redone; it never starts a second operation. Record: ${operation.file}.`;
-        try {
-            try {
-                await options?.onPrepared?.({ requestId: operation.requestId, file: operation.file });
-            }
-            catch {
-                operation.reject();
-                throw new ToolRequestError('Tool request preparation failed; no operation was sent');
-            }
-            const capabilityResponse = await fetch(this.toolsRequestUrl(AGENT_TOOL_OPERATION_CAPABILITIES_PATH), {
-                headers: this.authHeaders(),
-                redirect: 'error',
-                signal: options?.signal
-                    ? AbortSignal.any([options.signal, AbortSignal.timeout(30_000)])
-                    : AbortSignal.timeout(30_000),
-            });
-            if (!capabilityResponse.ok) {
-                if (capabilityResponse.status === 403) {
-                    const pending = pendingAccountActivationError(403, parseErrorPayload(await capabilityResponse.clone().text().catch(() => '')));
-                    if (pending) {
-                        if (operation.createdNew && !operation.settledOnly)
-                            operation.reject();
-                        throw pending;
-                    }
-                }
-                await capabilityResponse.body?.cancel();
-                throw new ToolRequestError(`Business tool protocol unavailable (${capabilityResponse.status}); no operation was sent`);
-            }
-            const capabilities = (await capabilityResponse.json());
-            if (capabilities.protocol !== AGENT_TOOL_OPERATION_PROTOCOL ||
-                capabilities.settledOnly !== true)
-                throw new ToolRequestError('Business tool protocol is incompatible; no operation was sent');
-            const res = await fetch(url, {
-                method: 'POST',
-                redirect: 'error',
-                signal: options?.signal
-                    ? AbortSignal.any([options.signal, AbortSignal.timeout(30 * 60_000)])
-                    : AbortSignal.timeout(30 * 60_000),
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...this.authHeaders(),
-                    [AGENT_TOOL_OPERATION_HEADERS.protocol]: AGENT_TOOL_OPERATION_PROTOCOL,
-                    [AGENT_TOOL_OPERATION_HEADERS.requestId]: operation.requestId,
-                    ...(operation.settledOnly ? { [AGENT_TOOL_OPERATION_HEADERS.settledOnly]: 'true' } : {}),
-                },
-                body: serializedBody,
-            });
-            if (res.headers.get(AGENT_TOOL_OPERATION_HEADERS.protocol) !== AGENT_TOOL_OPERATION_PROTOCOL ||
-                res.headers.get(AGENT_TOOL_OPERATION_HEADERS.requestId) !== operation.requestId) {
-                if (res.status === 403) {
-                    const pending = pendingAccountActivationError(403, parseErrorPayload(await res.clone().text().catch(() => '')));
-                    if (pending) {
-                        if (operation.createdNew && !operation.settledOnly)
-                            operation.reject();
-                        throw pending;
-                    }
-                }
-                await res.body?.cancel();
-                // Possibly an instance that ignores identities: a rerun may only read the receipt.
-                operation.requireReceipt();
-                throw new Error('Business did not acknowledge a durable receipt; outcome remains unconfirmed');
-            }
-            if (!res.ok) {
-                const text = await res.text().catch(() => res.statusText);
-                const pending = pendingAccountActivationError(res.status, parseErrorPayload(text));
-                if (pending)
-                    throw pending;
-                const code = errorCode(text);
-                if (res.status === 409 && code === 'business_operation_in_progress')
-                    throw new ToolRequestError(`API 409: ${text}\nTool request ${operation.requestId} is still running. Rerun the ` +
-                        'same command later to get its result.');
-                if (res.status === 409 && code === 'business_operation_requires_reconciliation')
-                    throw new ToolRequestError(recoverId !== undefined
-                        ? // A receipt query never runs the request, even for a tool that can be safely redone.
-                            `API 409: ${text}\nTool request ${operation.requestId} has no settled result yet. ` +
-                                'Rerun the same command without PLAYCRAFT_TOOL_REQUEST_ID: a tool that can be ' +
-                                'safely redone continues this request; any other tool then needs reconciliation.'
-                        : `API 409: ${text}\nTool request ${operation.requestId} needs reconciliation: its ` +
-                            'outcome is unknown, and rerunning the same command will not run it again. Only ' +
-                            'after confirming it had no effect, rerun with PLAYCRAFT_TOOL_NEW_REQUEST=1 to ' +
-                            'start a new operation.');
-                if (res.status >= 400 && res.status < 500) {
-                    // The request itself was refused and not carried out: a rerun is a new operation.
-                    operation.reject();
-                    throw new ToolRequestError(`API ${res.status}: ${text}`);
-                }
-                throw new Error(`API ${res.status}: ${text}`);
-            }
-            const result = (await res.json());
-            operation.complete();
-            return result;
-        }
-        catch (error) {
-            if (error instanceof ToolRequestError || error instanceof AccountActivationError)
-                throw error;
-            throw new Error(`${error instanceof Error ? error.message : String(error)}\n${operation.settledOnly
-                ? `Tool request ${operation.requestId}; record: ${operation.file}. Its settled result is not available yet.`
-                : unknownOutcome}`);
-        }
-        finally {
-            operation.release();
+        if (!res.ok) {
+            const text = await res.text().catch(() => res.statusText);
+            throw new Error(`API ${res.status}: ${text}`);
         }
+        return res.json();
     }
-    async get(path, params, options) {
+    async get(path, params) {
         const url = this.toolsRequestUrl(path);
         if (params) {
             for (const [k, v] of Object.entries(params)) {
@@ -201,62 +93,27 @@ export class AgentApiClient {
         }
         const res = await fetch(url, {
             headers: this.authHeaders(),
-            redirect: 'error',
-            signal: options?.signal ?? AbortSignal.timeout(30_000),
         });
         if (!res.ok) {
             const text = await res.text().catch(() => res.statusText);
-            const pending = pendingAccountActivationError(res.status, parseErrorPayload(text));
-            if (pending)
-                throw pending;
             throw new Error(`API ${res.status}: ${text}`);
         }
         return res.json();
     }
-    /** Stream only to the authenticated, same-service video upload endpoint. */
-    async putVideoMedia(path, body, headers, signal) {
-        if (!/^\/video-media\/[a-f0-9-]{36}\/content\?/.test(path))
-            throw new Error('invalid_video_upload_target');
-        const url = this.toolsRequestUrl(path);
-        const keys = [...url.searchParams.keys()].sort();
-        if (keys.join(',') !== 'expires,signature,workspaceId')
-            throw new Error('invalid_video_upload_target');
-        const allowed = new Set(['content-type', 'content-md5', 'content-length']);
-        if (Object.keys(headers).some(key => !allowed.has(key.toLowerCase())))
-            throw new Error('invalid_video_upload_headers');
-        const response = await fetch(url, {
-            method: 'PUT', redirect: 'error', signal,
-            headers: { ...headers, ...this.authHeaders() },
-            body: body,
-            duplex: 'half',
-        });
-        if (!response.ok) {
-            await response.body?.cancel();
-            throw new Error(`video_upload_failed:${response.status}`);
-        }
-        await response.body?.cancel();
-    }
     /**
      * 按顺序搜索本地 .playcraft.json 文件（沙箱内或项目目录）。
      * 与全局 login 配置（~/.playcraft/config.json）不同，前者专用于沙箱 token。
      */
     static loadLocalConfig() {
-        const ancestors = [];
-        for (let directory = process.cwd();; directory = dirname(directory)) {
-            ancestors.push(join(directory, '.playcraft.json'));
-            if (dirname(directory) === directory)
-                break;
-        }
         const searchPaths = [
-            process.env.PLAYCRAFT_SANDBOX_CONFIG_PATH || '/workspaces/.playcraft.json',
-            ...ancestors,
+            join(process.cwd(), '.playcraft.json'),
             '/project/.playcraft.json',
             join(homedir(), '.playcraft.json'),
         ];
         for (const p of searchPaths) {
             if (existsSync(p)) {
                 try {
-                    return { ...JSON.parse(readFileSync(p, 'utf-8')), credentialFile: p };
+                    return JSON.parse(readFileSync(p, 'utf-8'));
                 }
                 catch {
                     continue;
@@ -266,15 +123,3 @@ export class AgentApiClient {
         return { apiUrl: '', token: '' };
     }
 }
-/** A failure whose meaning is settled; no recovery hint applies. */
-class ToolRequestError extends Error {
-}
-function errorCode(text) {
-    try {
-        const message = JSON.parse(text).message;
-        return typeof message === 'string' ? message : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}