mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-17 13:01:24 +00:00
* feat(capabilities): add shared agent capability layer for MCP and CLI Introduce a registry-driven capability foundation so terminal, SFTP, vault, and port-forward tools can be extended from one policy and surface definition. Wire mcpServerBridge permission checks and the Skills CLI RPC client through the shared layer without changing existing AI runtime behavior. Co-authored-by: Cursor <cursoragent@cursor.com> * fix(capabilities): restore SFTP cancel gating and home RPC timeout Match legacy mcpServerBridge behavior by blocking SFTP write RPCs after chat cancel and treating sftp/home as a long-running operation for timeout budget calculation. Co-authored-by: Cursor <cursoragent@cursor.com> --------- Co-authored-by: Cursor <cursoragent@cursor.com>
714 lines
27 KiB
JavaScript
714 lines
27 KiB
JavaScript
#!/usr/bin/env node
|
|
"use strict";
|
|
|
|
const path = require("node:path");
|
|
|
|
const { connectClient, createError } = require("./netcattyRpcClient.cjs");
|
|
const { listCliCapabilities } = require("../capabilities/adapters/cliAdapter.cjs");
|
|
const { CAPABILITY_STATUS } = require("../capabilities/constants.cjs");
|
|
|
|
function printHelp() {
|
|
process.stdout.write(
|
|
"Netcatty Tool CLI\n\n" +
|
|
"Usage:\n" +
|
|
" netcatty-tool-cli status [--json]\n" +
|
|
" netcatty-tool-cli env --chat-session <id> [--json] [--scope-session <session-id> ...]\n" +
|
|
" netcatty-tool-cli session --session <id> --chat-session <id> [--json] [--scope-session <session-id> ...]\n" +
|
|
" netcatty-tool-cli exec --session <id> --chat-session <id> [--json] [--] <shell-ready-command>\n" +
|
|
" netcatty-tool-cli job-start --session <id> --chat-session <id> [--json] [--] <shell-ready-command>\n" +
|
|
" netcatty-tool-cli job-poll --job <id> --chat-session <id> [--offset <n>] [--json]\n" +
|
|
" netcatty-tool-cli job-stop --job <id> --chat-session <id> [--json]\n" +
|
|
" netcatty-tool-cli sftp list --session <id> --remote-path <remote-path> --chat-session <id> [--encoding <enc>] [--json] [--scope-session <session-id> ...]\n" +
|
|
" netcatty-tool-cli sftp read --session <id> --remote-path <remote-path> --chat-session <id> [--encoding <enc>] [--json] [--scope-session <session-id> ...]\n" +
|
|
" netcatty-tool-cli sftp write --session <id> --remote-path <remote-path> --content <text> --chat-session <id> [--encoding <enc>] [--json] [--scope-session <session-id> ...]\n" +
|
|
" netcatty-tool-cli sftp download --session <id> --remote-path <remote-path> --local-path <local-path> --chat-session <id> [--encoding <enc>] [--json] [--scope-session <session-id> ...]\n" +
|
|
" netcatty-tool-cli sftp upload --session <id> --local-path <local-path> --remote-path <remote-path> --chat-session <id> [--encoding <enc>] [--json] [--scope-session <session-id> ...]\n" +
|
|
" netcatty-tool-cli sftp mkdir --session <id> --remote-path <remote-path> --chat-session <id> [--encoding <enc>] [--json] [--scope-session <session-id> ...]\n" +
|
|
" netcatty-tool-cli sftp delete --session <id> --remote-path <remote-path> --chat-session <id> [--encoding <enc>] [--json] [--scope-session <session-id> ...]\n" +
|
|
" netcatty-tool-cli sftp rename --session <id> --old-remote-path <remote-path> --new-remote-path <remote-path> --chat-session <id> [--encoding <enc>] [--json] [--scope-session <session-id> ...]\n" +
|
|
" netcatty-tool-cli sftp stat --session <id> --remote-path <remote-path> --chat-session <id> [--encoding <enc>] [--json] [--scope-session <session-id> ...]\n" +
|
|
" netcatty-tool-cli sftp chmod --session <id> --remote-path <remote-path> --mode <octal> --chat-session <id> [--encoding <enc>] [--json] [--scope-session <session-id> ...]\n" +
|
|
" netcatty-tool-cli sftp home --session <id> --chat-session <id> [--json] [--scope-session <session-id> ...]\n" +
|
|
" netcatty-tool-cli cancel --chat-session <id> [--json]\n" +
|
|
" netcatty-tool-cli resume --chat-session <id> [--json]\n" +
|
|
" netcatty-tool-cli capabilities [--json] [--status implemented|planned|all]\n" +
|
|
" netcatty-tool-cli help\n\n" +
|
|
"Examples:\n" +
|
|
" netcatty-tool-cli status --json\n" +
|
|
" netcatty-tool-cli env --chat-session ai_123 --json\n" +
|
|
" netcatty-tool-cli session --session sess_123 --json --chat-session ai_123\n" +
|
|
" netcatty-tool-cli exec --session sess_123 --chat-session ai_123 --json -- \"pwd\"\n" +
|
|
" netcatty-tool-cli job-start --session sess_123 --chat-session ai_123 --json -- \"npm run dev\"\n" +
|
|
" netcatty-tool-cli job-poll --job job_123 --chat-session ai_123 --offset 0 --json\n" +
|
|
" netcatty-tool-cli sftp list --session sess_123 --remote-path /etc --chat-session ai_123 --json\n" +
|
|
" netcatty-tool-cli sftp download --session sess_123 --remote-path /etc/hosts --local-path ./hosts.txt --chat-session ai_123 --json\n\n" +
|
|
"Notes:\n" +
|
|
" - Start the Netcatty desktop app before using this CLI.\n" +
|
|
" - This CLI is intended as an internal Skills + CLI transport, not a general customer-facing shell tool.\n" +
|
|
" - `env` and `session` always require --chat-session <id>.\n" +
|
|
" - `exec` always requires both --session <id> and --chat-session <id>.\n" +
|
|
" - `job-start` always requires both --session <id> and --chat-session <id>.\n" +
|
|
" - `job-poll` and `job-stop` always require both --job <id> and --chat-session <id>.\n" +
|
|
" - Every `sftp <op>` always requires both --session <id> and --chat-session <id>, and only works on connected SSH-backed sessions.\n" +
|
|
" - After `--`, pass exactly one shell-ready command string. Preserve quoting inside that one argument.\n" +
|
|
" - `cancel` stops in-flight execs, session-backed SFTP transfers, and running jobs for that chat session, then blocks further execs until `resume`.\n",
|
|
);
|
|
}
|
|
|
|
function toErrorPayload(err) {
|
|
return {
|
|
ok: false,
|
|
error: {
|
|
code: err?.code || "UNKNOWN_ERROR",
|
|
message: err?.message || String(err),
|
|
},
|
|
};
|
|
}
|
|
|
|
function readFlagValue(args, index) {
|
|
return index < args.length ? args[index] : null;
|
|
}
|
|
|
|
function parseArgs(argv) {
|
|
const args = argv.slice(2);
|
|
const opts = {
|
|
json: false,
|
|
chatSessionId: null,
|
|
scopedSessionIds: [],
|
|
sessionId: null,
|
|
jobId: null,
|
|
offset: null,
|
|
remotePath: null,
|
|
localPath: null,
|
|
oldRemotePath: null,
|
|
newRemotePath: null,
|
|
content: null,
|
|
mode: null,
|
|
encoding: null,
|
|
command: [],
|
|
};
|
|
|
|
const positionals = [];
|
|
for (let i = 0; i < args.length; i += 1) {
|
|
const arg = args[i];
|
|
if (arg === "--") {
|
|
opts.command = args.slice(i + 1);
|
|
break;
|
|
}
|
|
if (arg === "--json") {
|
|
opts.json = true;
|
|
continue;
|
|
}
|
|
if (arg === "--chat-session") {
|
|
opts.chatSessionId = readFlagValue(args, i + 1);
|
|
i += 1;
|
|
continue;
|
|
}
|
|
if (arg === "--scope-session") {
|
|
const value = readFlagValue(args, i + 1);
|
|
if (value) opts.scopedSessionIds.push(value);
|
|
i += 1;
|
|
continue;
|
|
}
|
|
if (arg === "--session") {
|
|
opts.sessionId = readFlagValue(args, i + 1);
|
|
i += 1;
|
|
continue;
|
|
}
|
|
if (arg === "--job") {
|
|
opts.jobId = readFlagValue(args, i + 1);
|
|
i += 1;
|
|
continue;
|
|
}
|
|
if (arg === "--offset") {
|
|
const value = readFlagValue(args, i + 1);
|
|
opts.offset = value == null ? null : Number(value);
|
|
i += 1;
|
|
continue;
|
|
}
|
|
if (arg === "--remote-path") {
|
|
opts.remotePath = readFlagValue(args, i + 1);
|
|
i += 1;
|
|
continue;
|
|
}
|
|
if (arg === "--local-path") {
|
|
opts.localPath = readFlagValue(args, i + 1);
|
|
i += 1;
|
|
continue;
|
|
}
|
|
if (arg === "--old-remote-path") {
|
|
opts.oldRemotePath = readFlagValue(args, i + 1);
|
|
i += 1;
|
|
continue;
|
|
}
|
|
if (arg === "--new-remote-path") {
|
|
opts.newRemotePath = readFlagValue(args, i + 1);
|
|
i += 1;
|
|
continue;
|
|
}
|
|
if (arg === "--content") {
|
|
opts.content = readFlagValue(args, i + 1);
|
|
i += 1;
|
|
continue;
|
|
}
|
|
if (arg === "--mode") {
|
|
opts.mode = readFlagValue(args, i + 1);
|
|
i += 1;
|
|
continue;
|
|
}
|
|
if (arg === "--encoding") {
|
|
opts.encoding = readFlagValue(args, i + 1);
|
|
i += 1;
|
|
continue;
|
|
}
|
|
positionals.push(arg);
|
|
}
|
|
|
|
return { positionals, opts };
|
|
}
|
|
|
|
function formatEnvText(ctx) {
|
|
const header = [
|
|
`Environment: ${ctx.environment || "netcatty-terminal"}`,
|
|
`Hosts: ${ctx.hostCount || 0}`,
|
|
];
|
|
if (!Array.isArray(ctx.hosts) || ctx.hosts.length === 0) {
|
|
return `${header.join("\n")}\n\nNo hosts are available in the current scope.\n`;
|
|
}
|
|
const rows = ctx.hosts.map((host) => {
|
|
const details = [
|
|
host.sessionId,
|
|
host.label || host.hostname || "(unnamed)",
|
|
host.protocol || "unknown",
|
|
host.os || host.deviceType || host.shellType || "unknown",
|
|
host.connected === false ? "disconnected" : "connected",
|
|
];
|
|
return details.join("\t");
|
|
});
|
|
return `${header.join("\n")}\n\n${rows.join("\n")}\n`;
|
|
}
|
|
|
|
function formatExecText(result) {
|
|
const parts = [];
|
|
if (result.stdout) parts.push(result.stdout.replace(/\n$/, ""));
|
|
if (result.stderr) parts.push(`[stderr] ${result.stderr.replace(/\n$/, "")}`);
|
|
if (result.exitCode != null) parts.push(`[exit code: ${result.exitCode}]`);
|
|
if (parts.length === 0) {
|
|
parts.push("[no output]");
|
|
}
|
|
return `${parts.join("\n")}\n`;
|
|
}
|
|
|
|
function formatJobText(result) {
|
|
const lines = [
|
|
`Job: ${result.jobId || ""}`,
|
|
`Session: ${result.sessionId || ""}`,
|
|
`Status: ${result.status || "unknown"}`,
|
|
];
|
|
if (result.startedAt) lines.push(`Started: ${new Date(result.startedAt).toISOString()}`);
|
|
if (result.updatedAt) lines.push(`Updated: ${new Date(result.updatedAt).toISOString()}`);
|
|
if (typeof result.exitCode === "number") lines.push(`Exit Code: ${result.exitCode}`);
|
|
if (result.error) lines.push(`Error: ${result.error}`);
|
|
const outputText = typeof result.output === "string" ? result.output : "";
|
|
if (outputText) {
|
|
lines.push("");
|
|
lines.push(outputText.replace(/\n$/, ""));
|
|
}
|
|
return `${lines.join("\n")}\n`;
|
|
}
|
|
|
|
function buildScopeParams(opts) {
|
|
const params = {};
|
|
if (opts.chatSessionId) {
|
|
params.chatSessionId = opts.chatSessionId;
|
|
}
|
|
if (Array.isArray(opts.scopedSessionIds) && opts.scopedSessionIds.length > 0) {
|
|
params.scopedSessionIds = opts.scopedSessionIds;
|
|
}
|
|
return params;
|
|
}
|
|
|
|
function findHostOrThrow(ctx, sessionId) {
|
|
const host = Array.isArray(ctx?.hosts)
|
|
? ctx.hosts.find((item) => item.sessionId === sessionId)
|
|
: null;
|
|
if (!host) {
|
|
throw createError("SESSION_NOT_FOUND", `Session "${sessionId}" is not available in the current scope.`);
|
|
}
|
|
return host;
|
|
}
|
|
|
|
async function resolveTargetHost(client, opts) {
|
|
const ctx = await client.call("netcatty/getContext", buildScopeParams(opts));
|
|
if (opts.sessionId) {
|
|
return findHostOrThrow(ctx, opts.sessionId);
|
|
}
|
|
throw createError(
|
|
"INVALID_ARGUMENT",
|
|
"Missing required --session <id>. Run env --json to inspect available sessions first.",
|
|
);
|
|
}
|
|
|
|
function getSftpCapabilityError(host) {
|
|
if (!host) return "SFTP target session is unavailable.";
|
|
if (host.connected === false) {
|
|
return `Session "${host.sessionId}" is not connected. Reconnect it before using SFTP.`;
|
|
}
|
|
const protocol = String(host.protocol || "").toLowerCase();
|
|
const deviceType = String(host.deviceType || "").toLowerCase();
|
|
if (protocol === "ssh") {
|
|
return null;
|
|
}
|
|
if (protocol === "local") {
|
|
return "SFTP is not available for local sessions. Use normal local filesystem tools instead.";
|
|
}
|
|
if (protocol === "mosh") {
|
|
return "SFTP is not available for Mosh sessions. Open an SSH session for this host or use another transfer path.";
|
|
}
|
|
if (protocol === "telnet") {
|
|
return "SFTP is not available for Telnet sessions. Open an SSH session for this host or use another transfer path.";
|
|
}
|
|
if (protocol === "serial" || deviceType === "network") {
|
|
return "SFTP is not available for serial or network-device sessions. Use exec/vendor CLI commands or another transfer path.";
|
|
}
|
|
if (protocol) {
|
|
return `SFTP is not available for ${protocol} sessions. Open an SSH session for this host or use another transfer path.`;
|
|
}
|
|
return "SFTP is only available for connected SSH-backed sessions.";
|
|
}
|
|
|
|
function formatSessionText(host) {
|
|
const lines = [
|
|
`Session: ${host.sessionId}`,
|
|
`Label: ${host.label || "(unnamed)"}`,
|
|
`Hostname: ${host.hostname || ""}`,
|
|
`Protocol: ${host.protocol || "unknown"}`,
|
|
`OS: ${host.os || ""}`,
|
|
`Username: ${host.username || ""}`,
|
|
`Shell Type: ${host.shellType || ""}`,
|
|
`Device Type: ${host.deviceType || ""}`,
|
|
`Connected: ${host.connected === false ? "false" : "true"}`,
|
|
];
|
|
return `${lines.join("\n")}\n`;
|
|
}
|
|
|
|
function formatStatusText(status) {
|
|
const lines = [
|
|
"Netcatty Tool Status",
|
|
`Permission Mode: ${status.permissionMode || "unknown"}`,
|
|
`Command Timeout (ms): ${status.commandTimeoutMs ?? "unknown"}`,
|
|
`Max Iterations: ${status.maxIterations ?? "unknown"}`,
|
|
`Sessions: ${status.sessionCount ?? 0}`,
|
|
`Scoped Contexts: ${status.scopedContextCount ?? 0}`,
|
|
`Active Executions: ${status.activeExecutionCount ?? 0}`,
|
|
`Active Chat Execution Locks: ${status.activeChatExecutionCount ?? 0}`,
|
|
`Pending Approvals: ${status.pendingApprovalCount ?? 0}`,
|
|
`Discovery File: ${status.discoveryFilePath || "(none)"}`,
|
|
];
|
|
return `${lines.join("\n")}\n`;
|
|
}
|
|
|
|
function formatSftpListText(entries) {
|
|
if (!Array.isArray(entries) || entries.length === 0) {
|
|
return "No entries.\n";
|
|
}
|
|
const rows = entries.map((entry) => [
|
|
entry.type || "file",
|
|
entry.name || "",
|
|
entry.size || "",
|
|
entry.permissions || "",
|
|
entry.lastModified || "",
|
|
].join("\t"));
|
|
return `Type\tName\tSize\tPermissions\tModified\n${rows.join("\n")}\n`;
|
|
}
|
|
|
|
function getSingleCommandOrThrow(opts, commandName) {
|
|
if (!opts.command.length) {
|
|
throw createError("INVALID_ARGUMENT", "Missing command after --.");
|
|
}
|
|
if (opts.command.length !== 1) {
|
|
throw createError(
|
|
"INVALID_ARGUMENT",
|
|
`${commandName} expects exactly one shell-ready command string after --. Preserve quoting in a single argument instead of passing multiple tokens.`,
|
|
);
|
|
}
|
|
return opts.command[0];
|
|
}
|
|
|
|
function ensureBridgeCallOk(result, defaultCode, defaultMessage) {
|
|
if (!result || result.ok !== false) {
|
|
return result;
|
|
}
|
|
const err = createError(result.code || defaultCode, result.error || defaultMessage);
|
|
err.details = result;
|
|
throw err;
|
|
}
|
|
|
|
async function run() {
|
|
const { positionals, opts } = parseArgs(process.argv);
|
|
const [command, subcommand] = positionals;
|
|
|
|
if (!command || command === "help" || command === "--help" || command === "-h") {
|
|
printHelp();
|
|
process.exit(0);
|
|
}
|
|
|
|
if (command === "capabilities") {
|
|
const hasStatusFlag = process.argv.includes("--status");
|
|
const statusArg = hasStatusFlag
|
|
? process.argv[process.argv.indexOf("--status") + 1]
|
|
: CAPABILITY_STATUS.IMPLEMENTED;
|
|
const status = statusArg === "all" ? null : statusArg;
|
|
const payload = {
|
|
ok: true,
|
|
capabilities: listCliCapabilities(
|
|
hasStatusFlag && statusArg === "all"
|
|
? { status: null }
|
|
: { status },
|
|
),
|
|
};
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(payload, null, 2)}\n`
|
|
: `${payload.capabilities.map((entry) => entry.command.join(" ")).join("\n")}\n`);
|
|
process.exit(0);
|
|
}
|
|
|
|
let client = null;
|
|
try {
|
|
client = await connectClient();
|
|
|
|
if (command === "status") {
|
|
const result = await client.call("netcatty/getStatus", {});
|
|
const output = opts.json ? JSON.stringify(result, null, 2) : formatStatusText(result);
|
|
process.stdout.write(`${output}${opts.json ? "\n" : ""}`);
|
|
return;
|
|
}
|
|
|
|
if (command === "env") {
|
|
if (!opts.chatSessionId) {
|
|
throw createError("INVALID_ARGUMENT", "Missing required --chat-session <id> for env.");
|
|
}
|
|
const params = buildScopeParams(opts);
|
|
const result = await client.call("netcatty/getContext", params);
|
|
const output = opts.json ? JSON.stringify({ ok: true, ...result }, null, 2) : formatEnvText(result);
|
|
process.stdout.write(`${output}${opts.json ? "\n" : ""}`);
|
|
return;
|
|
}
|
|
|
|
if (command === "session") {
|
|
if (!opts.chatSessionId) {
|
|
throw createError("INVALID_ARGUMENT", "Missing required --chat-session <id> for session.");
|
|
}
|
|
const host = await resolveTargetHost(client, opts);
|
|
const payload = { ok: true, host };
|
|
const output = opts.json ? JSON.stringify(payload, null, 2) : formatSessionText(host);
|
|
process.stdout.write(`${output}${opts.json ? "\n" : ""}`);
|
|
return;
|
|
}
|
|
|
|
if (command === "exec") {
|
|
if (!opts.chatSessionId) {
|
|
throw createError("INVALID_ARGUMENT", "Missing required --chat-session <id> for exec.");
|
|
}
|
|
const shellCommand = getSingleCommandOrThrow(opts, "exec");
|
|
const host = await resolveTargetHost(client, opts);
|
|
const rpcParams = {
|
|
sessionId: host.sessionId,
|
|
command: shellCommand,
|
|
chatSessionId: opts.chatSessionId,
|
|
};
|
|
const result = await client.call("netcatty/exec", rpcParams);
|
|
if (result.ok === false) {
|
|
const err = createError(result.code || "EXEC_FAILED", result.error || "Command failed");
|
|
err.details = result;
|
|
throw err;
|
|
}
|
|
if (opts.json) {
|
|
process.stdout.write(`${JSON.stringify({ ok: true, ...result }, null, 2)}\n`);
|
|
} else {
|
|
process.stdout.write(formatExecText(result));
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (command === "job-start") {
|
|
if (!opts.chatSessionId) {
|
|
throw createError("INVALID_ARGUMENT", "Missing required --chat-session <id> for job-start.");
|
|
}
|
|
const shellCommand = getSingleCommandOrThrow(opts, "job-start");
|
|
const host = await resolveTargetHost(client, opts);
|
|
const result = await client.call("netcatty/jobStart", {
|
|
sessionId: host.sessionId,
|
|
command: shellCommand,
|
|
chatSessionId: opts.chatSessionId,
|
|
});
|
|
if (!result.ok) {
|
|
throw createError(result.code || "JOB_START_FAILED", result.error || "Failed to start long-running command");
|
|
}
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(result, null, 2)}\n`
|
|
: formatJobText(result));
|
|
return;
|
|
}
|
|
|
|
if (command === "job-poll") {
|
|
if (!opts.chatSessionId) {
|
|
throw createError("INVALID_ARGUMENT", "Missing required --chat-session <id> for job-poll.");
|
|
}
|
|
if (!opts.jobId) {
|
|
throw createError("INVALID_ARGUMENT", "Missing required --job <id> for job-poll.");
|
|
}
|
|
const offset = Number.isFinite(opts.offset) && opts.offset >= 0 ? opts.offset : 0;
|
|
const result = await client.call("netcatty/jobPoll", {
|
|
jobId: opts.jobId,
|
|
offset,
|
|
chatSessionId: opts.chatSessionId,
|
|
...buildScopeParams(opts),
|
|
});
|
|
if (!result.ok) {
|
|
throw createError(result.code || "JOB_POLL_FAILED", result.error || "Failed to poll long-running command");
|
|
}
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(result, null, 2)}\n`
|
|
: formatJobText(result));
|
|
return;
|
|
}
|
|
|
|
if (command === "job-stop") {
|
|
if (!opts.chatSessionId) {
|
|
throw createError("INVALID_ARGUMENT", "Missing required --chat-session <id> for job-stop.");
|
|
}
|
|
if (!opts.jobId) {
|
|
throw createError("INVALID_ARGUMENT", "Missing required --job <id> for job-stop.");
|
|
}
|
|
const result = await client.call("netcatty/jobStop", {
|
|
jobId: opts.jobId,
|
|
chatSessionId: opts.chatSessionId,
|
|
...buildScopeParams(opts),
|
|
});
|
|
if (!result.ok) {
|
|
throw createError(result.code || "JOB_STOP_FAILED", result.error || "Failed to stop long-running command");
|
|
}
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(result, null, 2)}\n`
|
|
: formatJobText(result));
|
|
return;
|
|
}
|
|
|
|
if (command === "sftp") {
|
|
if (!opts.chatSessionId) {
|
|
throw createError("INVALID_ARGUMENT", "Missing required --chat-session <id> for sftp.");
|
|
}
|
|
if (!subcommand || subcommand === "help") {
|
|
printHelp();
|
|
return;
|
|
}
|
|
|
|
const host = await resolveTargetHost(client, opts);
|
|
const sftpCapabilityError = getSftpCapabilityError(host);
|
|
if (sftpCapabilityError) {
|
|
throw createError("SFTP_UNSUPPORTED_SESSION", sftpCapabilityError);
|
|
}
|
|
const buildSftpParams = () => {
|
|
const params = {
|
|
sessionId: host.sessionId,
|
|
chatSessionId: opts.chatSessionId,
|
|
...buildScopeParams(opts),
|
|
};
|
|
if (opts.remotePath) params.remotePath = opts.remotePath;
|
|
if (opts.localPath) params.localPath = path.resolve(opts.localPath);
|
|
if (opts.remotePath) params.path = opts.remotePath;
|
|
if (opts.oldRemotePath) params.oldPath = opts.oldRemotePath;
|
|
if (opts.newRemotePath) params.newPath = opts.newRemotePath;
|
|
if (opts.content != null) params.content = opts.content;
|
|
if (opts.mode) params.mode = opts.mode;
|
|
if (opts.encoding) params.encoding = opts.encoding;
|
|
return params;
|
|
};
|
|
|
|
if (subcommand === "list") {
|
|
if (!opts.remotePath) throw createError("INVALID_ARGUMENT", "Missing required --remote-path <remote-path> for sftp list.");
|
|
const result = ensureBridgeCallOk(
|
|
await client.call("netcatty/sftp/list", buildSftpParams()),
|
|
"SFTP_LIST_FAILED",
|
|
"Failed to list remote directory",
|
|
);
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(result, null, 2)}\n`
|
|
: formatSftpListText(result.entries));
|
|
return;
|
|
}
|
|
|
|
if (subcommand === "read") {
|
|
if (!opts.remotePath) throw createError("INVALID_ARGUMENT", "Missing required --remote-path <remote-path> for sftp read.");
|
|
const result = ensureBridgeCallOk(
|
|
await client.call("netcatty/sftp/read", buildSftpParams()),
|
|
"SFTP_READ_FAILED",
|
|
"Failed to read remote file",
|
|
);
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(result, null, 2)}\n`
|
|
: `${result.content}${result.content?.endsWith("\n") ? "" : "\n"}`);
|
|
return;
|
|
}
|
|
|
|
if (subcommand === "write") {
|
|
if (!opts.remotePath) throw createError("INVALID_ARGUMENT", "Missing required --remote-path <remote-path> for sftp write.");
|
|
if (opts.content == null) throw createError("INVALID_ARGUMENT", "Missing required --content <text> for sftp write.");
|
|
const result = ensureBridgeCallOk(
|
|
await client.call("netcatty/sftp/write", buildSftpParams()),
|
|
"SFTP_WRITE_FAILED",
|
|
"Failed to write remote file",
|
|
);
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(result, null, 2)}\n`
|
|
: `Wrote ${opts.remotePath}.\n`);
|
|
return;
|
|
}
|
|
|
|
if (subcommand === "download") {
|
|
if (!opts.remotePath || !opts.localPath) {
|
|
throw createError("INVALID_ARGUMENT", "Missing required --remote-path and --local-path for sftp download.");
|
|
}
|
|
const result = ensureBridgeCallOk(
|
|
await client.call("netcatty/sftp/download", buildSftpParams()),
|
|
"SFTP_DOWNLOAD_FAILED",
|
|
"Failed to download remote file",
|
|
);
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(result, null, 2)}\n`
|
|
: `Downloaded ${opts.remotePath} -> ${opts.localPath}.\n`);
|
|
return;
|
|
}
|
|
|
|
if (subcommand === "upload") {
|
|
if (!opts.remotePath || !opts.localPath) {
|
|
throw createError("INVALID_ARGUMENT", "Missing required --local-path and --remote-path for sftp upload.");
|
|
}
|
|
const result = ensureBridgeCallOk(
|
|
await client.call("netcatty/sftp/upload", buildSftpParams()),
|
|
"SFTP_UPLOAD_FAILED",
|
|
"Failed to upload local file",
|
|
);
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(result, null, 2)}\n`
|
|
: `Uploaded ${opts.localPath} -> ${opts.remotePath}.\n`);
|
|
return;
|
|
}
|
|
|
|
if (subcommand === "mkdir") {
|
|
if (!opts.remotePath) throw createError("INVALID_ARGUMENT", "Missing required --remote-path <remote-path> for sftp mkdir.");
|
|
const result = ensureBridgeCallOk(
|
|
await client.call("netcatty/sftp/mkdir", buildSftpParams()),
|
|
"SFTP_MKDIR_FAILED",
|
|
"Failed to create remote directory",
|
|
);
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(result, null, 2)}\n`
|
|
: `Created ${opts.remotePath}.\n`);
|
|
return;
|
|
}
|
|
|
|
if (subcommand === "delete") {
|
|
if (!opts.remotePath) throw createError("INVALID_ARGUMENT", "Missing required --remote-path <remote-path> for sftp delete.");
|
|
const result = ensureBridgeCallOk(
|
|
await client.call("netcatty/sftp/delete", buildSftpParams()),
|
|
"SFTP_DELETE_FAILED",
|
|
"Failed to delete remote path",
|
|
);
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(result, null, 2)}\n`
|
|
: `Deleted ${opts.remotePath}.\n`);
|
|
return;
|
|
}
|
|
|
|
if (subcommand === "rename") {
|
|
if (!opts.oldRemotePath || !opts.newRemotePath) {
|
|
throw createError("INVALID_ARGUMENT", "Missing required --old-remote-path and --new-remote-path for sftp rename.");
|
|
}
|
|
const result = ensureBridgeCallOk(
|
|
await client.call("netcatty/sftp/rename", buildSftpParams()),
|
|
"SFTP_RENAME_FAILED",
|
|
"Failed to rename remote path",
|
|
);
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(result, null, 2)}\n`
|
|
: `Renamed ${opts.oldRemotePath} -> ${opts.newRemotePath}.\n`);
|
|
return;
|
|
}
|
|
|
|
if (subcommand === "stat") {
|
|
if (!opts.remotePath) throw createError("INVALID_ARGUMENT", "Missing required --remote-path <remote-path> for sftp stat.");
|
|
const result = ensureBridgeCallOk(
|
|
await client.call("netcatty/sftp/stat", buildSftpParams()),
|
|
"SFTP_STAT_FAILED",
|
|
"Failed to stat remote path",
|
|
);
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(result, null, 2)}\n`
|
|
: `${JSON.stringify(result.stat, null, 2)}\n`);
|
|
return;
|
|
}
|
|
|
|
if (subcommand === "chmod") {
|
|
if (!opts.remotePath || !opts.mode) {
|
|
throw createError("INVALID_ARGUMENT", "Missing required --remote-path and --mode for sftp chmod.");
|
|
}
|
|
const result = ensureBridgeCallOk(
|
|
await client.call("netcatty/sftp/chmod", buildSftpParams()),
|
|
"SFTP_CHMOD_FAILED",
|
|
"Failed to chmod remote path",
|
|
);
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(result, null, 2)}\n`
|
|
: `Changed mode of ${opts.remotePath} to ${opts.mode}.\n`);
|
|
return;
|
|
}
|
|
|
|
if (subcommand === "home") {
|
|
const result = ensureBridgeCallOk(
|
|
await client.call("netcatty/sftp/home", buildSftpParams()),
|
|
"SFTP_HOME_FAILED",
|
|
"Failed to resolve remote home directory",
|
|
);
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(result, null, 2)}\n`
|
|
: `${result.homeDir}\n`);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (command === "cancel" || command === "resume") {
|
|
if (!opts.chatSessionId) {
|
|
throw createError("INVALID_ARGUMENT", `Missing required --chat-session <id> for ${command}.`);
|
|
}
|
|
const cancelled = command === "cancel";
|
|
const result = await client.call("netcatty/setCancelled", {
|
|
chatSessionId: opts.chatSessionId,
|
|
cancelled,
|
|
});
|
|
const payload = { ok: true, ...result };
|
|
process.stdout.write(opts.json
|
|
? `${JSON.stringify(payload, null, 2)}\n`
|
|
: `Chat session ${opts.chatSessionId} ${cancelled ? "cancelled" : "resumed"}.\n`);
|
|
return;
|
|
}
|
|
|
|
throw createError("INVALID_ARGUMENT", `Unknown command: ${positionals.join(" ")}`);
|
|
} catch (err) {
|
|
const payload = toErrorPayload(err);
|
|
if (err?.details && typeof err.details === "object") {
|
|
payload.error = {
|
|
...payload.error,
|
|
...err.details,
|
|
};
|
|
}
|
|
process.stderr.write(`${JSON.stringify(payload, null, 2)}\n`);
|
|
process.exit(1);
|
|
} finally {
|
|
client?.close?.();
|
|
}
|
|
}
|
|
|
|
run();
|