@psnext/slingcli 2.5.20260719-2 → 2.5.20260722-2

package/bin/sling-default-package-policy.js

@@ -0,0 +1,26 @@
+function getPackageSource(entry) {
+  if (typeof entry === "string") return entry;
+  if (typeof entry === "object" && entry !== null) {
+    return typeof entry.source === "string" ? entry.source : null;
+  }
+  return null;
+}
+
+export function getStartupPackageActions(config, installedPackages) {
+  const unsupportedPackageSources = new Set(
+    (config.unsupportedPackages || []).map(getPackageSource).filter((source) => source !== null),
+  );
+  const packageSources = (config.packages || []).map(getPackageSource).filter((source) => source !== null);
+
+  const unsupportedPackagesToRemove = [...installedPackages].filter((source) =>
+    unsupportedPackageSources.has(source),
+  );
+  const packagesToInstall = packageSources.filter(
+    (source) => !installedPackages.has(source) && !unsupportedPackageSources.has(source),
+  );
+
+  return {
+    unsupportedPackagesToRemove,
+    packagesToInstall,
+  };
+}

package/bin/sling.js

@@ -27,6 +27,7 @@ import { homedir } from "node:os";
 import { spawn } from "node:child_process";
 import readline from "node:readline/promises";
 import semver from "semver";
+import { getStartupPackageActions } from "./sling-default-package-policy.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -202,15 +203,14 @@ function syncBundledSkills() {
   }
 }
 
-async function checkAndInstallPackages(argv = process.argv.slice(2)) {
+export async function checkAndInstallPackages(argv = process.argv.slice(2)) {
   if (shouldSkipAutoInstall(argv)) return;
 
   const configPath = IS_DEV ? path.resolve(__dirname, "./sling-default-packages.json") : path.resolve(__dirname, "../sling-default-packages.json");
   if (!existsSync(configPath)) return;
 
-  let installed = new Set();
-  let unsupported = new Set();
   const settingsPath = path.resolve(homedir(), ".sling/agent/settings.json");
+  let installed = new Set();
   if (existsSync(settingsPath)) {
     try {
       const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
@@ -218,20 +218,18 @@ async function checkAndInstallPackages(argv = process.argv.slice(2)) {
         const source = typeof p === "object" && p !== null ? p.source : p;
         installed.add(source);
       }
-      for (const p of settings.unsupportedPackages || []) {
-        const source = typeof p === "object" && p !== null ? p.source : p;
-        unsupported.add(source);
-      }
     } catch {}
   }
 
   try {
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    const { unsupportedPackagesToRemove, packagesToInstall } = getStartupPackageActions(config, installed);
 
-    //uninstall unsupported packages
-    for (const u of unsupported) {
+    // uninstall unsupported packages
+    for (const u of unsupportedPackagesToRemove) {
       console.log(`Removing unsupported package ${u}...`);
       try {
-        await runCommand(process.execPath, [__filename, "remove", "-g", u]);
+        await runCommand(process.execPath, [__filename, "remove", u]);
         console.log(`✓ Removed ${u}`);
       } catch (err) {
         console.error(`✗ Failed to remove ${u}:`, err.message);
@@ -239,10 +237,9 @@ async function checkAndInstallPackages(argv = process.argv.slice(2)) {
       }
     }
 
-    //remove unsupported packages from installed set
-    for (const u of unsupported) installed.delete(u);
+    // remove unsupported packages from installed set
+    for (const u of unsupportedPackagesToRemove) installed.delete(u);
 
-    const config = JSON.parse(readFileSync(configPath, "utf-8"));
     const updateDefaultPackage = shouldUpdateDefaultPackage(argv);
 
     if (updateDefaultPackage) {
@@ -256,14 +253,10 @@ async function checkAndInstallPackages(argv = process.argv.slice(2)) {
         console.error("You can manually update them later with: sling update --extensions");
       }
     }
-    const packages = (config.packages || []).filter((p) => {
-      const source = typeof p === "object" && p !== null ? p.source : p;
-      return !installed.has(source);
-    });
-    if (packages.length === 0) return;
+    if (packagesToInstall.length === 0) return;
 
     console.log("\nInstalling default packages...");
-    for (const pkg of packages) {
+    for (const pkg of packagesToInstall) {
       console.log(`Installing ${pkg}...`);
       try {
         // Pass -g so promptInstallScopeIfNeeded skips the scope prompt and
@@ -456,7 +449,9 @@ async function run() {
   }
 }
 
-run().catch((err) => {
-  console.error(err instanceof Error ? err.message : String(err));
-  process.exit(1);
-});
+//if (process.argv[1] === __filename) {
+  run().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
+//}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/experimental/BufferJsonShapeDeserializer.js

@@ -0,0 +1,182 @@
+import { determineTimestampFormat } from "@smithy/core/protocols";
+import { NormalizedSchema } from "@smithy/core/schema";
+import { LazyJsonString, NumericValue, parseEpochTimestamp, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, } from "@smithy/core/serde";
+import { fromBase64 } from "@smithy/core/serde";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { UnionSerde } from "../../UnionSerde";
+import { jsonReviver } from "../jsonReviver";
+import { parseJsonBody } from "../parseJsonBody";
+let canParseBuffer;
+function detectBufferParsing() {
+    if (canParseBuffer === undefined) {
+        try {
+            const result = JSON.parse(new Uint8Array([0x7b, 0x7d]));
+            canParseBuffer = result !== null && typeof result === "object";
+        }
+        catch {
+            canParseBuffer = false;
+        }
+    }
+    return canParseBuffer;
+}
+export class BufferJsonShapeDeserializer extends SerdeContextConfig {
+    settings;
+    constructor(settings) {
+        super();
+        this.settings = settings;
+    }
+    async read(schema, data) {
+        let parsed;
+        if (typeof data === "string") {
+            parsed = JSON.parse(data, jsonReviver);
+        }
+        else if (data instanceof Uint8Array && detectBufferParsing()) {
+            parsed = JSON.parse(data, jsonReviver);
+        }
+        else {
+            parsed = await parseJsonBody(data, this.serdeContext);
+        }
+        return this._read(schema, parsed);
+    }
+    readObject(schema, data) {
+        return this._read(schema, data);
+    }
+    _read(schema, value) {
+        const isObject = value !== null && typeof value === "object";
+        const ns = NormalizedSchema.of(schema);
+        if (isObject) {
+            if (ns.isStructSchema()) {
+                return this._readStruct(ns, value);
+            }
+            if (Array.isArray(value) && ns.isListSchema()) {
+                const listMember = ns.getValueSchema();
+                for (let i = 0; i < value.length; ++i) {
+                    value[i] = this._read(listMember, value[i]);
+                }
+                return value;
+            }
+            if (ns.isMapSchema()) {
+                const mapMember = ns.getValueSchema();
+                const map = value;
+                for (const k in map) {
+                    map[k] = this._read(mapMember, map[k]);
+                }
+                return map;
+            }
+        }
+        if (ns.isBlobSchema() && typeof value === "string") {
+            return fromBase64(value);
+        }
+        const mediaType = ns.getMergedTraits().mediaType;
+        if (ns.isStringSchema() && typeof value === "string" && mediaType) {
+            const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
+            if (isJson) {
+                return LazyJsonString.from(value);
+            }
+            return value;
+        }
+        if (ns.isTimestampSchema() && value != null) {
+            const format = determineTimestampFormat(ns, this.settings);
+            switch (format) {
+                case 5:
+                    return parseRfc3339DateTimeWithOffset(value);
+                case 6:
+                    return parseRfc7231DateTime(value);
+                case 7:
+                    return parseEpochTimestamp(value);
+                default:
+                    console.warn("Missing timestamp format, parsing value with Date constructor:", value);
+                    return new Date(value);
+            }
+        }
+        if (ns.isBigIntegerSchema() && (typeof value === "number" || typeof value === "string")) {
+            return BigInt(value);
+        }
+        if (ns.isBigDecimalSchema() && value != undefined) {
+            if (value instanceof NumericValue) {
+                return value;
+            }
+            const untyped = value;
+            if (untyped.type === "bigDecimal" && "string" in untyped) {
+                return new NumericValue(untyped.string, untyped.type);
+            }
+            return new NumericValue(String(value), "bigDecimal");
+        }
+        if (ns.isNumericSchema() && typeof value === "string") {
+            switch (value) {
+                case "Infinity":
+                    return Infinity;
+                case "-Infinity":
+                    return -Infinity;
+                case "NaN":
+                    return NaN;
+            }
+            return value;
+        }
+        if (ns.isDocumentSchema()) {
+            if (isObject) {
+                if (Array.isArray(value)) {
+                    for (let i = 0; i < value.length; ++i) {
+                        const v = value[i];
+                        if (!(v instanceof NumericValue)) {
+                            value[i] = this._read(ns, v);
+                        }
+                    }
+                }
+                else {
+                    const doc = value;
+                    for (const k in doc) {
+                        const v = doc[k];
+                        if (!(v instanceof NumericValue)) {
+                            doc[k] = this._read(ns, v);
+                        }
+                    }
+                }
+                return value;
+            }
+            else {
+                return value;
+            }
+        }
+        return value;
+    }
+    _readStruct(ns, record) {
+        const union = ns.isUnionSchema();
+        const out = {};
+        let nameMap = void 0;
+        const { jsonName } = this.settings;
+        if (jsonName) {
+            nameMap = {};
+        }
+        let unionSerde;
+        if (union) {
+            unionSerde = new UnionSerde(record, out);
+        }
+        for (const [memberName, memberSchema] of ns.structIterator()) {
+            let fromKey = memberName;
+            if (jsonName) {
+                fromKey = memberSchema.getMergedTraits().jsonName ?? fromKey;
+                nameMap[fromKey] = memberName;
+            }
+            if (union) {
+                unionSerde.mark(fromKey);
+            }
+            if (record[fromKey] != null) {
+                out[memberName] = this._read(memberSchema, record[fromKey]);
+            }
+        }
+        if (union) {
+            unionSerde.writeUnknown();
+        }
+        else if (typeof record.__type === "string") {
+            for (const k in record) {
+                const v = record[k];
+                const t = jsonName ? (nameMap[k] ?? k) : k;
+                if (!(t in out)) {
+                    out[t] = v;
+                }
+            }
+        }
+        return out;
+    }
+}