direxio-deployer 0.1.0 → 0.1.1

package/scripts/lib/aws.sh

@@ -4,11 +4,15 @@
 # Some local proxy setups truncate AWS API TLS (UNEXPECTED_EOF). Bypass proxies
 # for AWS endpoints in every phase that calls aws.
 
+AWS_LIB_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck disable=SC1090
+source "$AWS_LIB_DIR/json.sh"
+
 aws_env_prep() {
   local region=${AWS_DEFAULT_REGION:-${AWS_REGION:-}}
   if [ -n "${STATE_JSON:-}" ] && [ -f "$STATE_JSON" ]; then
     local state_region
-    state_region=$(jq -r '.region // empty' "$STATE_JSON" 2>/dev/null || true)
+    state_region=$(json_get "$STATE_JSON" region 2>/dev/null || true)
     [ -n "$state_region" ] && region="$state_region"
   fi
   if [ -z "$region" ]; then

package/scripts/lib/json.sh

@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+# Portable JSON helpers backed by Node.js.
+
+JSON_LIB_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+JSON_HELPER="$JSON_LIB_DIR/../json.mjs"
+
+json_node() {
+  local uname_s node_path
+  if [ -n "${NODE:-}" ]; then
+    printf '%s\n' "$NODE"
+    return 0
+  fi
+  uname_s=$(uname -s 2>/dev/null || printf unknown)
+  if command -v node >/dev/null 2>&1; then
+    node_path=$(command -v node)
+    case "$uname_s:$node_path" in
+      Linux*:*.exe|Linux*:/mnt/*|Linux*:/c/*) ;;
+      *)
+        printf '%s\n' "$node_path"
+        return 0
+        ;;
+    esac
+  fi
+  case "$uname_s" in
+    Linux*)
+      local user_home
+      user_home=$(eval "printf '%s' ~${USER:-}" 2>/dev/null || true)
+      for node_path in "$HOME/.local/node/bin/node" "$user_home/.local/node/bin/node" /usr/local/bin/node /usr/bin/node; do
+        if [ -x "$node_path" ]; then
+          printf '%s\n' "$node_path"
+          return 0
+        fi
+      done
+      echo "POSIX node is required for JSON processing in Linux/WSL; Windows node.exe cannot read POSIX paths." >&2
+      return 1
+      ;;
+  esac
+  if command -v node.exe >/dev/null 2>&1; then
+    command -v node.exe
+    return 0
+  fi
+  echo "node is required for JSON processing." >&2
+  return 1
+}
+
+json_cli() {
+  local node_bin
+  node_bin=$(json_node) || return 1
+  "$node_bin" "$JSON_HELPER" "$@"
+}
+
+json_get() {
+  json_cli get "$@"
+}
+
+json_stdin_get() {
+  json_cli stdin-get "$@"
+}
+
+json_assert() {
+  json_cli assert "$@"
+}
+
+json_stdin_assert() {
+  json_cli stdin-assert "$@"
+}
+
+json_check() {
+  json_cli check "$@"
+}
+
+json_entries() {
+  json_cli entries "$@"
+}
+
+json_stdin_tsv() {
+  json_cli stdin-tsv "$@"
+}
+
+json_stdin_join() {
+  json_cli stdin-join "$@"
+}
+
+json_stdin_route53_a_values() {
+  json_cli stdin-route53-a-values "$@"
+}
+
+json_stdin_route53_a_present() {
+  json_cli stdin-route53-a-present "$@"
+}
+
+json_stdin_price_usd() {
+  json_cli stdin-price-usd "$@"
+}
+
+json_length() {
+  json_cli length "$@"
+}
+
+json_type() {
+  json_cli type "$@"
+}
+
+json_build() {
+  json_cli build "$@"
+}
+
+json_mutate() {
+  json_cli mutate "$@"
+}
+
+json_valid() {
+  json_cli valid "$@"
+}

package/scripts/lib/operation_report.sh

@@ -1,20 +1,25 @@
 #!/usr/bin/env bash
 # lib/operation_report.sh - redacted operation reports for deploy/destroy flows.
 
+OPERATION_REPORT_LIB_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck disable=SC1090
+source "$OPERATION_REPORT_LIB_DIR/json.sh"
+
 operation_report_now() {
   date -u +%Y-%m-%dT%H:%M:%SZ
 }
 
 operation_report_service_id() {
   local state=$1 service_id
-  service_id=$(jq -r '.agent_service_id // .domain // empty' "$state")
+  service_id=$(json_get "$state" agent_service_id)
+  [ -n "$service_id" ] || service_id=$(json_get "$state" domain)
   printf '%s\n' "${service_id:-unknown-service}"
 }
 
 operation_report_default_path() {
   local operation=$1 state=$2 service_id service_dir root
   service_id=$(operation_report_service_id "$state")
-  service_dir=$(jq -r '.agent_service_dir // empty' "$state")
+  service_dir=$(json_get "$state" agent_service_dir)
   [ -n "$service_dir" ] || service_dir=$(dirname "$state")
   case "$operation" in
     destroy)
@@ -29,199 +34,7 @@ operation_report_default_path() {
 
 operation_report_json() {
   local operation=$1 status=$2 state=$3 generated_at=$4
-  jq -n \
-    --arg operation_type "$operation" \
-    --arg status "$status" \
-    --arg generated_at "$generated_at" \
-    --arg state_json "$state" \
-    --slurpfile state "$state" '
-      $state[0] as $st |
-      def redacted_status:
-        if (($st.password // "") | tostring | length) > 0
-        then "available_in_state_password_field_redacted"
-        else "missing"
-        end;
-      def phase_statuses:
-        ($st.phases // {} | with_entries(.value = (.value.status // "unknown")));
-      def user_gate($gate; $default):
-        ($st.user_confirmations[$gate].status // $default);
-      def local_refresh_status:
-        if ($st.agent_install_status // "") == "refresh_pending"
-        then "refresh_pending"
-        else "current_or_not_recorded"
-        end;
-      def redact_text($value):
-        def redact_one($secret):
-          if (($secret // "") | tostring | length) > 0
-          then split($secret | tostring) | join("<redacted>")
-          else .
-          end;
-        ($value // "" | tostring)
-        | redact_one($st.password)
-        | redact_one($st.access_token)
-        | redact_one($st.agent_token)
-        | redact_one($st.matrix_access_token)
-        | redact_one($st.owner_access_token)
-        | redact_one($st.aws_secret_access_key)
-        | redact_one($st.aws_session_token)
-        | gsub("[0-9]{8,}"; "<redacted>");
-      def user_gate_detail($gate; $default):
-        ($st.user_confirmations[$gate] // {}) as $gate_state |
-        {
-          status: ($gate_state.status // $default),
-          ts: ($gate_state.ts // ""),
-          evidence: redact_text($gate_state.evidence // ""),
-          evidence_redacted: ((redact_text($gate_state.evidence // "")) != (($gate_state.evidence // "") | tostring))
-        }
-        + (if $gate == "agent_mcp_runtime" then {
-            runtime_summary_status: ($gate_state.runtime_summary_status // ""),
-            runtime_probe_confirmed: ($gate_state.runtime_probe_confirmed // false)
-          } else {} end);
-      def billable:
-        [
-          (if (($st.resources.instance_id // "") | tostring | length) > 0 then "EC2 \($st.resources.instance_id)" else empty end),
-          (if (($st.resources.root_volume_id // "") | tostring | length) > 0 then "EBS root volume \($st.resources.root_volume_id)" else empty end),
-          (if (($st.resources.public_ip // "") | tostring | length) > 0 then "public IPv4 \($st.resources.public_ip)" else empty end),
-          (if (($st.resources.eip_id // "") | tostring | length) > 0 then "Elastic IP \($st.resources.eip_id)" else empty end),
-          (if (($st.resources.route53_zone_id // "") | tostring | length) > 0 then "Route53 hosted zone \($st.resources.route53_zone_id)" else empty end)
-        ];
-      def destroy_status($key):
-        ($st.destroy_evidence[$key].status // "not_checked");
-      def status_not_in($status; $safe):
-        (($safe | index($status)) == null);
-      def destroy_billable_residue:
-        [
-          (if (($st.resources.instance_id // "") | tostring | length) > 0
-              and status_not_in(destroy_status("ec2_instance"); ["terminated", "not_found", "skipped"])
-           then "EC2 \($st.resources.instance_id) status=\(destroy_status("ec2_instance"))"
-           else empty end),
-          (if (($st.resources.root_volume_id // "") | tostring | length) > 0
-              and status_not_in(destroy_status("ebs_root_volume"); ["deleted", "skipped"])
-           then "EBS root volume \($st.resources.root_volume_id) status=\(destroy_status("ebs_root_volume"))"
-           else empty end),
-          (if (($st.resources.eip_id // "") | tostring | length) > 0
-              and status_not_in(destroy_status("elastic_ip"); ["released", "skipped"])
-           then "Elastic IP \($st.resources.eip_id) status=\(destroy_status("elastic_ip"))"
-           else empty end),
-          (if (($st.resources.route53_zone_id // "") | tostring | length) > 0
-              and status_not_in(destroy_status("route53_hosted_zone"); ["deleted", "skipped"])
-           then "Route53 hosted zone \($st.resources.route53_zone_id) status=\(destroy_status("route53_hosted_zone"))"
-           else empty end)
-        ];
-      {
-        operation_type: $operation_type,
-        status: $status,
-        generated_at: $generated_at,
-        domain: ($st.domain // ""),
-        service_id: ($st.agent_service_id // $st.domain // ""),
-        service_dir: ($st.agent_service_dir // ""),
-        state_json: $state_json,
-        delivery: {
-          app_domain: ($st.domain // ""),
-          product_completion_status: $status,
-          init_code_status: redacted_status,
-          init_code_secret_redacted: true,
-          user_path: "enter app_domain and the eight-digit initialization code in the App"
-        },
-        agent: {
-          node_id: ($st.agent_node_id // ""),
-          room_id: ($st.agent_room_id // ""),
-          runtime: ($st.agent_runtime // "unknown"),
-          service_id: ($st.agent_service_id // $st.domain // ""),
-          credentials_file: ($st.agent_credentials_file // "")
-        },
-        gates: {
-          automated: phase_statuses,
-          user_confirmation: {
-            app_initialization: user_gate("app_initialization"; "pending_user_confirmation"),
-            real_chat: user_gate("real_chat"; "pending_user_confirmation"),
-            agent_mcp_runtime: user_gate("agent_mcp_runtime"; "pending_runtime_confirmation")
-          },
-          user_confirmation_details: {
-            app_initialization: user_gate_detail("app_initialization"; "pending_user_confirmation"),
-            real_chat: user_gate_detail("real_chat"; "pending_user_confirmation"),
-            agent_mcp_runtime: user_gate_detail("agent_mcp_runtime"; "pending_runtime_confirmation")
-          }
-        },
-        runtime_checks: {
-          summary: ($st.runtime_checks.summary // {status: "not_run"}),
-          connect_daemon: ($st.runtime_checks.connect_daemon // {status: "not_run"}),
-          mcp_doctor: ($st.runtime_checks.mcp_doctor // {status: "not_run"}),
-          mcp_smoke: ($st.runtime_checks.mcp_smoke // {status: "not_run"}),
-          mcp_tools: ($st.runtime_checks.mcp_tools // {status: "not_run"})
-        },
-        credentials: {
-          status: local_refresh_status,
-          credentials_file: ($st.agent_credentials_file // ""),
-          contains_secrets: true,
-          values_redacted: true
-        },
-        connect: {
-          package: ($st.cc_connect_npm_package // "direxio-connent@latest"),
-          agent: ($st.cc_connect_agent // ""),
-          config: ($st.cc_connect_config // ""),
-          install_status: ($st.agent_install_status // "")
-        },
-        mcp: {
-          status: local_refresh_status,
-          package: ($st.mcp_npm_package // "direxio-mcp@latest"),
-          server_name: ($st.mcp_server_name // ""),
-          config_dir: ($st.mcp_config_dir // ""),
-          codex: ($st.mcp_codex_config // ""),
-          openclaw: ($st.mcp_openclaw_config // ""),
-          hermes: ($st.mcp_hermes_config // ""),
-          doctor: ($st.mcp_doctor_command // "")
-        },
-        resources: {
-          region: ($st.region // ""),
-          domain_mode: ($st.domain_mode // ""),
-          instance_type: ($st.instance_type // ""),
-          instance_id: ($st.resources.instance_id // ""),
-          root_volume_id: ($st.resources.root_volume_id // ""),
-          public_ip: ($st.resources.public_ip // ""),
-          eip_id: ($st.resources.eip_id // ""),
-          route53_zone_id: ($st.resources.route53_zone_id // ""),
-          route53_zone_name: ($st.resources.route53_zone_name // ""),
-          route53_zone_created_by_deployer: ($st.resources.route53_zone_created_by_deployer // ""),
-          route53_name_servers: ($st.resources.route53_name_servers // ""),
-          route53_existing_a_value: ($st.resources.route53_existing_a_value // ""),
-          route53_pending_a_value: ($st.resources.route53_pending_a_value // ""),
-          route53_overwrite_confirmed: ($st.resources.route53_overwrite_confirmed // ""),
-          sg_id: ($st.resources.sg_id // ""),
-          key_name: ($st.resources.key_name // "")
-        },
-        billing: {
-          keeps_billing_until_destroy: ($operation_type != "destroy"),
-          recorded_billable_resources: billable,
-          cost_estimate: ($st.cost_estimate // null),
-          destroy_cleanup_status: (
-            if $operation_type != "destroy" then "not_destroy"
-            elif (destroy_billable_residue | length) == 0 then "no_recorded_billable_resource_residue"
-            else "possible_billable_resource_residue"
-            end
-          ),
-          possible_remaining_billable_resources: (
-            if $operation_type == "destroy" then destroy_billable_residue else [] end
-          )
-        },
-        security: {
-          secrets_included: false,
-          values_redacted: true,
-          root_access_key_allowed: true,
-          temporary_iam_cleanup_required: true,
-          temporary_iam_cleanup_action: "if a temporary DirexioDeployer access key was used, delete or disable it after deployment, or reduce it to a maintenance-only policy"
-        }
-      }
-      + (if $operation_type == "destroy" then {
-          destroy: {
-            resources_processed_from_state: true,
-            user_managed_dns_not_removed: true,
-            purchased_domain_not_removed: true,
-            local_service_dir: ($st.agent_service_dir // ""),
-            evidence: ($st.destroy_evidence // {})
-          }
-        } else {} end)
-    '
+  json_cli operation-report "$operation" "$status" "$state" "$generated_at"
 }
 
 operation_report_write() {

package/scripts/lib/ops.sh

@@ -1,6 +1,10 @@
 #!/usr/bin/env bash
 # lib/ops.sh - existing-node update/reset helpers.
 
+OPS_LIB_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck disable=SC1090
+source "$OPS_LIB_DIR/json.sh"
+
 ops_state_path() {
   local explicit=${1:-}
   if [ -n "$explicit" ]; then
@@ -20,7 +24,8 @@ ops_require_state() {
 
 ops_state_get() {
   local state=$1 path=$2
-  jq -r "$path // empty" "$state"
+  path=${path#\.}
+  json_get "$state" "$path"
 }
 
 ops_sh_quote() {
@@ -201,26 +206,8 @@ EOF
 }
 
 ops_mark_refresh_pending() {
-  local state=$1 start_phase=${2:-S4_BOOTSTRAP_STACK} tmp
-  tmp="$state.tmp.$$"
-  jq --arg start "$start_phase" --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" '
-    del(
-      .password,
-      .access_token,
-      .agent_token,
-      .agent_room_id,
-      .user_confirmations,
-      .runtime_checks
-    )
-    | .agent_install_status = "refresh_pending"
-    | .phase = $start
-    | (if ($start == "S4_BOOTSTRAP_STACK") then
-        .phases.S4_BOOTSTRAP_STACK = {status:"pending", ts:$ts, evidence:"existing node operation requires fresh health check"}
-      else . end)
-    | .phases.S5_INIT_TOKENS = {status:"pending", ts:$ts, evidence:"existing node operation requires fresh bootstrap credentials"}
-    | .phases.S6_WIRE_LOCAL = {status:"pending", ts:$ts, evidence:"existing node operation requires local credentials and MCP refresh"}
-    | .phases.S7_VERIFY_E2E = {status:"pending", ts:$ts, evidence:"existing node operation requires fresh verification"}
-  ' "$state" > "$tmp" && mv "$tmp" "$state"
+  local state=$1 start_phase=${2:-S4_BOOTSTRAP_STACK}
+  json_mutate "$state" ops-refresh-pending "$start_phase" "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 }
 
 ops_write_report() {

package/scripts/lib/state.sh

@@ -2,7 +2,7 @@
 # lib/state.sh - state.json helpers for the deployment state machine.
 #
 # Sourced by orchestrate.sh and phases/*.sh. All state.json reads/writes go
-# through this file to keep structure and fields consistent. Requires jq.
+# through this file to keep structure and fields consistent. Requires Node.js.
 #
 # state.json path: $P2P_WORKDIR/state.json.
 # By default, DOMAIN=__DOMAIN__ maps to ~/.direxio/nodes/<service_id>/state.json.
@@ -12,6 +12,8 @@
 STATE_LIB_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 # shellcheck disable=SC1090
 source "$STATE_LIB_DIR/paths.sh"
+# shellcheck disable=SC1090
+source "$STATE_LIB_DIR/json.sh"
 
 # Phase list; order matters.
 PHASES=(
@@ -48,30 +50,8 @@ is_yes() {
 state_init() {
   mkdir -p "$P2P_WORKDIR"
   local run_id=${RUN_ID:-p2p-$(date -u +%Y%m%d-%H%M%S)}
-  local phases_json="{}"
-  local p
-  for p in "${PHASES[@]}"; do
-    phases_json=$(echo "$phases_json" | jq --arg k "$p" '. + {($k): {"status":"pending"}}')
-  done
-  jq -n \
-    --arg run_id "$run_id" \
-    --arg region "${AWS_DEFAULT_REGION:-${AWS_REGION:-}}" \
-    --argjson phases "$phases_json" \
-    --arg ts "$(_now)" \
-    '{
-       run_id: $run_id,
-       region: (if $region == "" then null else $region end),
-       domain_mode: null,
-       domain: null,
-       domain_confirmed_irreversible: false,
-       instance_type: null,
-       dns_ready: false,
-       existing_state_confirmed: false,
-       phase: "S0_PREREQ_AWS",
-       created_at: $ts,
-       phases: $phases,
-       resources: {}
-     }' > "$STATE_JSON"
+  : > "$STATE_JSON"
+  json_mutate "$STATE_JSON" state-init "$run_id" "${AWS_DEFAULT_REGION:-${AWS_REGION:-}}" "$(_now)" "${PHASES[@]}"
   log "Initialized state.json -> $STATE_JSON (run_id=$run_id)"
 }
 
@@ -80,35 +60,29 @@ state_ensure() {
   [ -f "$STATE_JSON" ] || state_init
 }
 
-# Atomic write using a jq filter.
-_state_write() {
-  local filter=$1; shift
-  local tmp="$STATE_JSON.tmp.$$"
-  jq "$@" "$filter" "$STATE_JSON" > "$tmp" && mv "$tmp" "$STATE_JSON"
-}
-
 # Top-level field accessors.
-state_get()      { jq -r --arg k "$1" '.[$k] // empty' "$STATE_JSON"; }
-state_set()      { _state_write '.[$k] = $v' --arg k "$1" --arg v "$2"; }
-state_set_raw()  { _state_write ".$1 = $2"; }
+state_get()      { json_get "$STATE_JSON" "$1"; }
+state_set()      { json_mutate "$STATE_JSON" set-string "$1" "$2"; }
+state_set_raw()  { json_mutate "$STATE_JSON" set-json "$1" "$2"; }
+state_set_object() {
+  local path=$1 object_json
+  shift
+  object_json=$(json_build object "$@")
+  json_mutate "$STATE_JSON" set-json "$path" "$object_json"
+}
 
 # Resource records used by destroy.sh.
-res_set() { _state_write '.resources[$k] = $v' --arg k "$1" --arg v "$2"; }
-res_get() { jq -r --arg k "$1" '.resources[$k] // empty' "$STATE_JSON"; }
+res_set() { json_mutate "$STATE_JSON" set-string "resources.$1" "$2"; }
+res_get() { json_get "$STATE_JSON" "resources.$1"; }
 
 # Phase status helpers.
 # phase_status <PHASE>
-phase_status() { jq -r --arg p "$1" '.phases[$p].status // "pending"' "$STATE_JSON"; }
+phase_status() { json_get "$STATE_JSON" "phases.$1.status" "pending"; }
 
 # phase_set <PHASE> <status> [evidence]
 phase_set() {
   local p=$1 st=$2 ev=${3:-}
-  _state_write '
-    .phases[$p].status = $st
-    | .phases[$p].ts = $ts
-    | (if $ev != "" then .phases[$p].evidence = $ev else . end)
-    | .phase = $p
-  ' --arg p "$p" --arg st "$st" --arg ev "$ev" --arg ts "$(_now)"
+  json_mutate "$STATE_JSON" phase-set "$p" "$st" "$(_now)" "$ev"
 }
 
 # Find the first phase whose status is not done.

package/scripts/mcp-tools-list.mjs

@@ -65,15 +65,32 @@ function send(message) {
 
 function readFrames() {
   while (true) {
+    const headerEnd = stdout.indexOf("\r\n\r\n");
+    if (headerEnd >= 0) {
+      const header = stdout.subarray(0, headerEnd).toString("utf8");
+      const match = /^Content-Length:\s*(\d+)/im.exec(header);
+      if (match) {
+        const length = Number.parseInt(match[1], 10);
+        const bodyStart = headerEnd + 4;
+        if (stdout.length < bodyStart + length) return;
+        const body = stdout.subarray(bodyStart, bodyStart + length).toString("utf8");
+        stdout = stdout.subarray(bodyStart + length);
+        recordMessage(JSON.parse(body));
+        continue;
+      }
+    }
     const lineEnd = stdout.indexOf("\n");
     if (lineEnd < 0) return;
     const line = stdout.subarray(0, lineEnd).toString("utf8").replace(/\r$/, "");
     stdout = stdout.subarray(lineEnd + 1);
     if (line.length === 0) continue;
-    const message = JSON.parse(line);
-    if (typeof message.id !== "undefined") {
-      responses.set(message.id, message);
-    }
+    recordMessage(JSON.parse(line));
+  }
+}
+
+function recordMessage(message) {
+  if (typeof message.id !== "undefined") {
+    responses.set(message.id, message);
   }
 }