huaweicloud-devkit 1.0.2-dev.0 → 1.0.2-dev.11

package/plugins/huaweicloud-core/src/tools.mjs

@@ -6,6 +6,10 @@ import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 import { searchMarketplace } from './search-market.mjs';
+import { execWithSession, closeSession, DEFAULT_WORKSPACE_ID } from './sandbox/session-manager.mjs';
+import { hdkitCheckUser, hdkitSignAgreement, hdkitConnect, hdkitCredentials } from './sandbox/hdkitservice-api.mjs';
+import { getAuthStatus, syncAuth } from './auth/service.mjs';
+import { readGlobalCredentials, writeObsConfig as writeObsConfigFile } from './auth/credentials.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const SKILLS_ROOT_DEV = join(__dirname, '..', 'skills');
@@ -285,6 +289,104 @@ export const TOOL_DEFINITIONS = [
       },
     },
   },
+  {
+    name: 'huaweicloud_auth_status',
+    description: 'Check unified Huawei Cloud authentication status across the global credential vault, OBS, KooCLI, and all supported agent MCP registrations. Returns only redacted/status information, never credentials.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        target: { type: 'string', description: 'Agent target to check: opencode, codex, codex-desktop, codearts, workbuddy, or all (default).' },
+      },
+    },
+  },
+  {
+    name: 'huaweicloud_auth_sync',
+    description: 'Synchronize credentials from the global Huawei Cloud credential vault to OBS and report agent registration status. Does not write secrets into any agent config.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        target: { type: 'string', description: 'Agent target to report after sync: opencode, codex, codex-desktop, codearts, workbuddy, or all (default).' },
+      },
+    },
+  },
+  {
+    name: 'huaweicloud_sandbox_exec_with_session',
+    description: 'Execute a command on a workspace terminal with session reuse (state persists across calls). Shell state (cd, env vars, aliases) carries over between calls.',
+    inputSchema: {
+      type: 'object',
+      required: ['command'],
+      properties: {
+        command: { type: 'string', description: 'The shell command to execute on the remote workspace' },
+        workspace_id: { type: 'string', description: 'The workspace ID' },
+        username: { type: 'string', description: 'Login username for the remote terminal (default: root)' },
+        timeout_ms: { type: 'number', description: 'Execution timeout in milliseconds (default: 30000)' },
+      },
+    },
+  },
+  {
+    name: 'huaweicloud_sandbox_close_session',
+    description: 'Close the persistent terminal session for a workspace.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        workspace_id: { type: 'string', description: 'The workspace ID' },
+        username: { type: 'string', description: 'Login username (default: root)' },
+      },
+    },
+  },
+  {
+    name: 'huaweicloud_sandbox_check_user',
+    description: 'Check if the current user has completed real-name verification and signed the required agreements. Returns realnameVerified and agreementSigned status.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'huaweicloud_sandbox_sign_agreement',
+    description: 'Sign all unsigned or outdated agreements for the current user. Required before huaweicloud_sandbox_connect if check-user returns agreementSigned=false.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'huaweicloud_sandbox_connect',
+    description: 'Connect to a sandbox via hdkitservice. One user one instance - reuses existing sandbox if available, otherwise creates a new one. Returns session_id, dev_stage_id, connection_id, and connection_address.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        source: { type: 'string', description: 'Source identifier (default: WEB). Options: VSCODE, CLI, WEB, WEBVNC, WEBPTY, WEBIDE, CURSOR, etc.' },
+        template_id: { type: 'string', description: 'Template ID; overrides server default (only for new sandbox)' },
+        flavor_id: { type: 'string', description: 'Flavor ID; overrides server default (only for new sandbox)' },
+        env: { type: 'object', description: 'Environment variables to set in the sandbox (only for new sandbox)' },
+        git: {
+          type: 'object',
+          description: 'Git repo config (only for new sandbox)',
+          properties: {
+            repo_url: { type: 'string', description: 'Git repository URL' },
+            repo_branch: { type: 'string', description: 'Git branch' },
+            repo_name: { type: 'string', description: 'Repository name' },
+            target_path: { type: 'string', description: 'Clone target path in sandbox' },
+            open_type: { type: 'string', description: 'Open type' },
+          },
+        },
+      },
+    },
+  },
+  {
+    name: 'huaweicloud_sandbox_credentials',
+    description: 'Configure temporary AK/SK for a sandbox via hdkitservice. Injects temporary credentials into the sandbox. The sandbox must be in RUNNING state.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        session_id: { type: 'string', description: 'Session ID from huaweicloud_sandbox_connect' },
+        dev_stage_id: { type: 'string', description: 'DevStation environment ID (alternative to session_id)' },
+        enable_sts: { type: 'boolean', description: 'Whether to enable STS temporary AK/SK (default: true)' },
+      },
+    },
+  },
+
 ];
 
 export async function callTool(name, args = {}) {
@@ -328,6 +430,31 @@ export async function callTool(name, args = {}) {
       return searchMarketplace(args.query || '', args.category || '');
     case 'huaweicloud_setup_obs_config':
       return setupObsConfig(args.profile);
+    case 'huaweicloud_auth_status':
+      return getAuthStatus(args.target || 'all');
+    case 'huaweicloud_auth_sync':
+      return syncAuth(args.target || 'all');
+    case 'huaweicloud_sandbox_exec_with_session': {
+      const sandboxWsId2 = args.workspace_id || DEFAULT_WORKSPACE_ID;
+      const sandboxUser2 = args.username || 'root';
+      const sandboxTimeout2 = args.timeout_ms || 30000;
+      const sandboxResult2 = await execWithSession(sandboxWsId2, args.command, sandboxUser2, sandboxTimeout2);
+      return { stdout: sandboxResult2.stdout, exitCode: sandboxResult2.exitCode };
+    }
+    case 'huaweicloud_sandbox_close_session': {
+      const sandboxWsId3 = args.workspace_id || DEFAULT_WORKSPACE_ID;
+      const sandboxUser3 = args.username || 'root';
+      const closed = await closeSession(sandboxWsId3, sandboxUser3);
+      return closed ? 'ok' : 'not_connected';
+    }
+    case 'huaweicloud_sandbox_check_user':
+      return await hdkitCheckUser();
+    case 'huaweicloud_sandbox_sign_agreement':
+      return await hdkitSignAgreement();
+    case 'huaweicloud_sandbox_connect':
+      return await hdkitConnect(args);
+    case 'huaweicloud_sandbox_credentials':
+      return await hdkitCredentials(args.session_id, args.dev_stage_id, args.enable_sts !== false);
     default:
       throw new Error(`Unknown tool: ${name}`);
   }
@@ -395,6 +522,33 @@ async function showProfileRedacted(profile) {
 }
 
 async function setupObsConfig(profile) {
+  const stored = readGlobalCredentials();
+  if (stored?.ak && stored?.sk) {
+    try {
+      const obs = writeObsConfigFile(stored);
+      return {
+        ok: true,
+        existed: false,
+        created: true,
+        path: obs.path,
+        region: stored.region,
+        endpoint: obs.endpoint,
+        source: 'global-credentials',
+        note: 'OBS credentials synced from the global credential vault. OBS commands (hcloud OBS ls, mb, cp, etc.) should now work.',
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error.message,
+        nextStep: 'Run "npx huaweicloud-devkit auth init" to refresh credentials and region.',
+      };
+    }
+  }
+
+  return setupObsConfigFromHcloud(profile);
+}
+
+async function setupObsConfigFromHcloud(profile) {
   const obsConfigPath = join(homedir(), '.obsutilconfig');
   if (existsSync(obsConfigPath)) {
     return { ok: true, existed: true, path: obsConfigPath, note: 'OBS config already exists. Delete ~/.obsutilconfig first if you need to re-sync.' };
@@ -409,7 +563,7 @@ async function setupObsConfig(profile) {
       ok: false,
       error: 'Failed to read hcloud profile.',
       detail: result.error || result.stderr || 'hcloud not installed or not configured',
-      nextStep: 'Run "hcloud configure init" outside agent chat, then retry.',
+      nextStep: 'Run "npx huaweicloud-devkit auth init" outside agent chat, then retry.',
     };
   }
 
@@ -435,7 +589,7 @@ async function setupObsConfig(profile) {
     return {
       ok: false,
       error: 'No credentials found in hcloud profile.',
-      nextStep: 'Run "hcloud configure init" outside agent chat to set up credentials first.',
+      nextStep: 'Run "npx huaweicloud-devkit auth init" outside agent chat to set up credentials first.',
     };
   }
 
@@ -448,7 +602,8 @@ async function setupObsConfig(profile) {
   }
 
   const endpoint = `https://obs.${region}.myhuaweicloud.com`;
-  const configContent = `[default]\r\nendpoint=${endpoint}\r\nak=${accessKeyId}\r\nsk=${secretAccessKey}\r\n`;
+  // Flat key=value format (no [default] section) as written by KooCLI 7.x `hcloud OBS config`.
+  const configContent = `endpoint=${endpoint}\nak=${accessKeyId}\nsk=${secretAccessKey}\n`;
 
   try {
     writeFileSync(obsConfigPath, configContent, { encoding: 'utf8', mode: 0o600 });
@@ -554,6 +709,7 @@ function serviceCatalog(intent = '') {
     { keywords: ['cts', 'audit', 'trace', 'tracker'], skills: ['huawei-cts'], services: ['CTS'] },
     { keywords: ['cbr', 'backup', 'restore', 'vault', 'snapshot'], skills: ['huawei-cbr'], services: ['CBR'] },
     { keywords: ['deployment', 'deploy', 'ci/cd', 'pipeline', 'release'], skills: ['huawei-deployment'], services: ['CloudDeploy'] },
+    { keywords: ['sandbox', 'devstation', 'workspace', 'terminal', 'preview', 'hwlink'], skills: ['huawei-sandbox'], services: ['Sandbox', 'DevStation'] },
     { keywords: ['dds', 'dcs', 'mongodb', 'redis', 'memcached', 'cache', 'document db'], skills: ['huawei-dds-dcs'], services: ['DDS', 'DCS'] },
 ];
   const matched = [];

package/plugins/huaweicloud-core/src/ws-exec/hwlink-exec-client.js

@@ -0,0 +1,427 @@
+import {
+  DEFAULT_TIMEOUT_MS,
+  WebSocketExecError,
+  buildMarkers,
+  buildShellCommands,
+  cleanCommandOutput,
+} from './ws-exec-client.js';
+import { HwlinkWebSocketMultiplexer } from './hwlink-multiplexer.js';
+import { HwlinkTerminalChannel } from './hwlink-terminal-channel.js';
+
+const decoder = new TextDecoder();
+const encoder = new TextEncoder();
+
+function normalizeCommand(command) {
+  if (!command || !String(command).trim()) {
+    throw new WebSocketExecError('missing command', 2);
+  }
+  return String(command).trim();
+}
+
+function normalizeTimeout(timeoutMs) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new WebSocketExecError('timeoutMs must be a positive number of milliseconds', 2);
+  }
+  return timeoutMs;
+}
+
+function normalizeSource(source) {
+  const numericSource = Number(source);
+  if (!Number.isInteger(numericSource) || numericSource < -0x80000000 || numericSource > 0xffffffff) {
+    throw new WebSocketExecError('hwlink source must be an int32 or uint32 number', 2);
+  }
+  return numericSource;
+}
+
+function normalizeUrl(url) {
+  if (!url || !String(url).trim()) {
+    throw new WebSocketExecError('hwlink url is required', 2);
+  }
+  return String(url);
+}
+
+function createHwlinkTerminal(options = {}) {
+  const {
+    url,
+    source,
+    username = 'root',
+    WebSocketImpl = globalThis.WebSocket,
+    protocol = 'devenv',
+    cols,
+    rows,
+    onFrame,
+    onData,
+    onError,
+    onClose,
+    trace = false,
+  } = options;
+
+  const normalizedUrl = normalizeUrl(url);
+  const normalizedSource = normalizeSource(source);
+  const mux = new HwlinkWebSocketMultiplexer(normalizedUrl, normalizedSource, {
+    WebSocketImpl,
+    protocol,
+    onFrame,
+    trace,
+  });
+  const term = new HwlinkTerminalChannel(username);
+  let closed = false;
+  let readySettled = false;
+  let readyResolve;
+  let readyReject;
+
+  const ready = new Promise((resolve, reject) => {
+    readyResolve = resolve;
+    readyReject = reject;
+  });
+
+  function settleReady(error) {
+    if (readySettled) return;
+    readySettled = true;
+    if (error) readyReject(error);
+    else readyResolve(handle);
+  }
+
+  function handleError(error, prefix) {
+    const wrapped = new WebSocketExecError(`${prefix}: ${error.message}`, 1, {
+      cause: error,
+      phase: readySettled ? 'open' : 'opening',
+    });
+    settleReady(wrapped);
+    if (onError) onError(wrapped);
+    close();
+  }
+
+  function handleClose() {
+    settleReady(new WebSocketExecError('hwlink terminal closed before ready', 1, {
+      phase: 'opening',
+    }));
+    if (closed) return;
+    closed = true;
+    if (onClose) onClose();
+  }
+
+  term.onReady(() => {
+    if (Number.isFinite(cols) && Number.isFinite(rows)) {
+      term.resize(cols, rows);
+    }
+    settleReady();
+  });
+  term.onData((data) => {
+    if (onData) onData(data);
+  });
+  term.onError((error) => handleError(error, 'hwlink terminal error'));
+  term.onClose(handleClose);
+  mux.onError = (error) => handleError(error, 'hwlink websocket error');
+  mux.onClose = handleClose;
+
+  function close() {
+    if (closed) return;
+    closed = true;
+    term.close();
+    mux.close();
+  }
+
+  const handle = {
+    url: normalizedUrl,
+    source: normalizedSource,
+    username,
+    mux,
+    term,
+    ready,
+    close,
+    resize: (nextCols, nextRows) => term.resize(nextCols, nextRows),
+    sendInput: (data) => term.sendInput(data),
+    sendText: (text) => term.sendText(text),
+  };
+
+  term.attach(mux);
+  return handle;
+}
+
+class HwlinkTerminalExecSession {
+  constructor(options = {}) {
+    const {
+      url,
+      source,
+      username = 'root',
+      timeoutMs = DEFAULT_TIMEOUT_MS,
+      WebSocketImpl = globalThis.WebSocket,
+      protocol = 'devenv',
+      cols,
+      rows,
+      onFrame,
+      onData,
+      trace = false,
+    } = options;
+
+    this.url = normalizeUrl(url);
+    this.source = normalizeSource(source);
+    this.username = username;
+    this.timeoutMs = normalizeTimeout(timeoutMs);
+    this.onData = onData;
+    this.initialCols = cols;
+    this.initialRows = rows;
+    this.state = 'opening';
+    this.readyBuffer = '';
+    this.inputEchoed = false;
+    this.pending = null;
+    this.queue = Promise.resolve();
+    this.readyMarkers = buildMarkers();
+    const { readyCommand } = buildShellCommands(this.readyMarkers);
+    this.readyCommand = readyCommand;
+
+    this.readyPromise = new Promise((resolve, reject) => {
+      this.resolveReady = resolve;
+      this.rejectReady = reject;
+    });
+
+    this.readyTimeout = setTimeout(() => {
+      this.fail(new WebSocketExecError(`hwlink terminal ready timeout after ${this.timeoutMs}ms`, 124, {
+        partialOutput: this.readyBuffer,
+        phase: 'opening',
+      }));
+    }, this.timeoutMs);
+
+    try {
+      this.mux = new HwlinkWebSocketMultiplexer(this.url, this.source, {
+        WebSocketImpl,
+        protocol,
+        onFrame,
+        trace,
+      });
+    } catch (error) {
+      clearTimeout(this.readyTimeout);
+      throw new WebSocketExecError(error.message, 2, { cause: error, phase: 'opening' });
+    }
+
+    this.term = new HwlinkTerminalChannel(username);
+    this.term.onData((data) => this.handleTerminalData(data));
+    this.term.onError((error) => {
+      this.fail(new WebSocketExecError(`hwlink terminal error: ${error.message}`, 1, {
+        cause: error,
+        phase: this.state,
+      }));
+    });
+    this.term.onReady(() => {
+      if (Number.isFinite(this.initialCols) && Number.isFinite(this.initialRows)) {
+        this.term.resize(this.initialCols, this.initialRows);
+      }
+      this.sendLine(this.readyCommand);
+    });
+    this.term.onClose(() => {
+      if (this.state !== 'closed') {
+        this.fail(new WebSocketExecError('hwlink terminal closed before completion marker', 1, {
+          phase: this.state,
+        }));
+      }
+    });
+    this.mux.onClose = () => {
+      if (this.state !== 'closed') {
+        this.fail(new WebSocketExecError('hwlink websocket closed before completion marker', 1, {
+          phase: this.state,
+        }));
+      }
+    };
+    this.mux.onError = (error) => {
+      if (this.state !== 'closed') {
+        this.fail(new WebSocketExecError(`hwlink websocket error: ${error.message}`, 1, {
+          cause: error,
+          phase: this.state,
+        }));
+      }
+    };
+
+    this.term.attach(this.mux);
+  }
+
+  ready() {
+    return this.readyPromise;
+  }
+
+  exec(command, options = {}) {
+    const run = () => this.runExec(command, options);
+    const result = this.queue.then(run, run);
+    this.queue = result.catch(() => {});
+    return result;
+  }
+
+  resize(cols, rows) {
+    this.term.resize(cols, rows);
+  }
+
+  close() {
+    if (this.state === 'closed') return;
+    const wasOpening = this.state === 'opening';
+    const pending = this.pending;
+    this.state = 'closed';
+    clearTimeout(this.readyTimeout);
+    this.pending = null;
+
+    if (wasOpening) {
+      this.rejectReady(new WebSocketExecError('hwlink terminal session closed before ready', 1, {
+        phase: 'opening',
+      }));
+    }
+
+    if (pending) {
+      clearTimeout(pending.timeout);
+      pending.reject(new WebSocketExecError('hwlink terminal session closed before completion marker', 1, {
+        phase: 'running',
+      }));
+    }
+
+    this.term.close();
+    this.mux.close();
+  }
+
+  fail(error) {
+    if (this.state === 'closed') return;
+
+    const wasOpening = this.state === 'opening';
+    const pending = this.pending;
+    this.state = 'closed';
+    this.pending = null;
+    clearTimeout(this.readyTimeout);
+
+    if (wasOpening) {
+      this.rejectReady(error);
+    }
+
+    if (pending) {
+      clearTimeout(pending.timeout);
+      pending.reject(error);
+    }
+
+    this.term.close();
+    this.mux.close();
+  }
+
+  handleTerminalData(data) {
+    if (this.state === 'closed') return;
+
+    const chunk = decoder.decode(data, { stream: true });
+    if (this.onData) this.onData(data, chunk);
+
+    if (this.state === 'opening') {
+      this.readyBuffer += chunk;
+      this.tryCompleteReady();
+      return;
+    }
+
+    if (this.pending) {
+      this.pending.buffer += chunk;
+      this.tryCompletePending();
+    }
+  }
+
+  tryCompleteReady() {
+    const readyIndex = this.readyBuffer.indexOf(this.readyMarkers.readyMarker);
+    if (readyIndex === -1) return;
+
+    this.inputEchoed = this.readyBuffer.slice(0, readyIndex).includes(this.readyCommand);
+    this.readyBuffer = '';
+    this.state = 'ready';
+    clearTimeout(this.readyTimeout);
+    this.resolveReady(this);
+  }
+
+  runExec(command, options = {}) {
+    if (this.state !== 'ready') {
+      return Promise.reject(new WebSocketExecError('hwlink terminal exec session is not ready', 1, {
+        phase: this.state,
+      }));
+    }
+
+    const shellCommand = normalizeCommand(command);
+    const timeoutMs = normalizeTimeout(options.timeoutMs === undefined ? this.timeoutMs : options.timeoutMs);
+    const markers = buildMarkers();
+    const { doneCommand } = buildShellCommands(markers);
+
+    return new Promise((resolve, reject) => {
+      this.pending = {
+        buffer: '',
+        command: shellCommand,
+        doneCommand,
+        markers,
+        reject,
+        resolve,
+        timeout: setTimeout(() => {
+          this.fail(new WebSocketExecError(`hwlink terminal exec timeout after ${timeoutMs}ms`, 124, {
+            partialOutput: this.pending ? this.pending.buffer : '',
+            phase: 'running',
+          }));
+        }, timeoutMs),
+      };
+
+      this.sendLine(shellCommand);
+      this.sendLine(doneCommand);
+    });
+  }
+
+  tryCompletePending() {
+    const pending = this.pending;
+    if (!pending) return;
+
+    const doneMatch = pending.buffer.match(pending.markers.donePattern);
+    if (!doneMatch || doneMatch.index === undefined) return;
+
+    const rawOutput = pending.buffer.slice(0, doneMatch.index);
+    const stdout = cleanCommandOutput(rawOutput, {
+      inputEchoed: this.inputEchoed,
+      command: pending.command,
+      doneCommand: pending.doneCommand,
+    });
+
+    clearTimeout(pending.timeout);
+    this.pending = null;
+    pending.resolve({
+      stdout,
+      exitCode: Number(doneMatch[1]),
+      url: this.url,
+      source: this.source,
+      username: this.username,
+      command: pending.command,
+    });
+  }
+
+  sendLine(line) {
+    this.term.sendInput(encoder.encode(`${line}\n`));
+  }
+}
+
+async function connectHwlinkTerminalSession(options = {}) {
+  const session = new HwlinkTerminalExecSession(options);
+  await session.ready();
+  return session;
+}
+
+async function connectHwlinkInteractiveTerminal(options = {}) {
+  const terminal = createHwlinkTerminal(options);
+  await terminal.ready;
+  return terminal;
+}
+
+async function executeHwlinkCommand(options = {}) {
+  const { command, timeoutMs = DEFAULT_TIMEOUT_MS, ...sessionOptions } = options;
+  const shellCommand = normalizeCommand(command);
+  const normalizedTimeoutMs = normalizeTimeout(timeoutMs);
+  const session = await connectHwlinkTerminalSession({
+    ...sessionOptions,
+    timeoutMs: normalizedTimeoutMs,
+  });
+  try {
+    return await session.exec(shellCommand, { timeoutMs: normalizedTimeoutMs });
+  } finally {
+    session.close();
+  }
+}
+
+export {
+  HwlinkTerminalExecSession,
+  connectHwlinkInteractiveTerminal,
+  connectHwlinkTerminalSession,
+  createHwlinkTerminal,
+  executeHwlinkCommand,
+  normalizeSource,
+};