@jingyi0605/codingns 0.8.1 → 0.8.5

package/vendor/better-sqlite3-win32-x64-node22/src/util/helpers.cpp

@@ -0,0 +1,109 @@
+inline v8::Local<v8::String> StringFromUtf8(v8::Isolate* isolate, const char* data, int length) {
+	return v8::String::NewFromUtf8(isolate, data, v8::NewStringType::kNormal, length).ToLocalChecked();
+}
+
+inline v8::Local<v8::String> InternalizedFromUtf8(v8::Isolate* isolate, const char* data, int length) {
+	return v8::String::NewFromUtf8(isolate, data, v8::NewStringType::kInternalized, length).ToLocalChecked();
+}
+
+inline v8::Local<v8::Value> InternalizedFromUtf8OrNull(v8::Isolate* isolate, const char* data, int length) {
+	if (data == NULL) return v8::Null(isolate);
+	return InternalizedFromUtf8(isolate, data, length);
+}
+
+inline v8::Local<v8::String> InternalizedFromLatin1(v8::Isolate* isolate, const char* str) {
+	return v8::String::NewFromOneByte(isolate, reinterpret_cast<const uint8_t*>(str), v8::NewStringType::kInternalized).ToLocalChecked();
+}
+
+inline void SetFrozen(v8::Isolate* isolate, v8::Local<v8::Context> ctx, v8::Local<v8::Object> obj, v8::Global<v8::String>& key, v8::Local<v8::Value> value) {
+	obj->DefineOwnProperty(ctx, key.Get(isolate), value, static_cast<v8::PropertyAttribute>(v8::DontDelete | v8::ReadOnly)).FromJust();
+}
+
+void ThrowError(const char* message) { EasyIsolate; isolate->ThrowException(v8::Exception::Error(StringFromUtf8(isolate, message, -1))); }
+void ThrowTypeError(const char* message) { EasyIsolate; isolate->ThrowException(v8::Exception::TypeError(StringFromUtf8(isolate, message, -1))); }
+void ThrowRangeError(const char* message) { EasyIsolate; isolate->ThrowException(v8::Exception::RangeError(StringFromUtf8(isolate, message, -1))); }
+
+// Determines whether to skip the given character at the start of an SQL string.
+inline bool IS_SKIPPED(char c) {
+	return c == ' ' || c == ';' || (c >= '\t' && c <= '\r');
+}
+
+// Allocates an empty array, without calling constructors/initializers.
+template<class T> inline T* ALLOC_ARRAY(size_t count) {
+	return static_cast<T*>(::operator new[](count * sizeof(T)));
+}
+
+// Deallocates an array, without calling destructors.
+template<class T> inline void FREE_ARRAY(T* array_pointer) {
+	::operator delete[](array_pointer);
+}
+
+v8::Local<v8::FunctionTemplate> NewConstructorTemplate(
+	v8::Isolate* isolate,
+	v8::Local<v8::External> data,
+	v8::FunctionCallback func,
+	const char* name
+) {
+	v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate, func, data);
+	t->InstanceTemplate()->SetInternalFieldCount(1);
+	t->SetClassName(InternalizedFromLatin1(isolate, name));
+	return t;
+}
+
+void SetPrototypeMethod(
+	v8::Isolate* isolate,
+	v8::Local<v8::External> data,
+	v8::Local<v8::FunctionTemplate> recv,
+	const char* name,
+	v8::FunctionCallback func
+) {
+	v8::HandleScope scope(isolate);
+	recv->PrototypeTemplate()->Set(
+		InternalizedFromLatin1(isolate, name),
+		v8::FunctionTemplate::New(isolate, func, data, v8::Signature::New(isolate, recv))
+	);
+}
+
+void SetPrototypeSymbolMethod(
+	v8::Isolate* isolate,
+	v8::Local<v8::External> data,
+	v8::Local<v8::FunctionTemplate> recv,
+	v8::Local<v8::Symbol> symbol,
+	v8::FunctionCallback func
+) {
+	v8::HandleScope scope(isolate);
+	recv->PrototypeTemplate()->Set(
+		symbol,
+		v8::FunctionTemplate::New(isolate, func, data, v8::Signature::New(isolate, recv))
+	);
+}
+
+void SetPrototypeGetter(
+	v8::Isolate* isolate,
+	v8::Local<v8::External> data,
+	v8::Local<v8::FunctionTemplate> recv,
+	const char* name,
+	v8::AccessorNameGetterCallback func
+) {
+	v8::HandleScope scope(isolate);
+	recv->InstanceTemplate()->SetNativeDataProperty(
+		InternalizedFromLatin1(isolate, name),
+		func,
+		0,
+		data
+	);
+}
+
+#if defined(V8_ENABLE_SANDBOX)
+// When V8 Sandbox is enabled (in newer Electron versions), we need to use Buffer::Copy
+// instead of Buffer::New to ensure the ArrayBuffer backing store is allocated inside the sandbox
+static inline v8::MaybeLocal<v8::Object> BufferSandboxNew(v8::Isolate* isolate, char* data, size_t length, void (*finalizeCallback)(char*, void*), void* finalizeHint) {
+    v8::MaybeLocal<v8::Object> buffer = node::Buffer::Copy(isolate, data, length);
+    finalizeCallback(data, finalizeHint);
+    return buffer;
+}
+#define SAFE_NEW_BUFFER(env, data, length, finalizeCallback, finalizeHint) BufferSandboxNew(env, data, length, finalizeCallback, finalizeHint)
+#else
+// When V8 Sandbox is not enabled, we can use the more efficient Buffer::New
+#define SAFE_NEW_BUFFER(env, data, length, finalizeCallback, finalizeHint) node::Buffer::New(env, data, length, finalizeCallback, finalizeHint)
+#endif

package/vendor/better-sqlite3-win32-x64-node22/src/util/macros.cpp

@@ -0,0 +1,83 @@
+#define NODE_ARGUMENTS const v8::FunctionCallbackInfo<v8::Value>&
+#define NODE_ARGUMENTS_POINTER const v8::FunctionCallbackInfo<v8::Value>*
+#define NODE_METHOD(name) void name(NODE_ARGUMENTS info)
+#define NODE_GETTER(name) void name(v8::Local<v8::Name> _, const v8::PropertyCallbackInfo<v8::Value>& info)
+#define INIT(name) v8::Local<v8::Function> name(v8::Isolate* isolate, v8::Local<v8::External> data)
+
+#if defined(V8_MAJOR_VERSION) && V8_MAJOR_VERSION >= 13
+// v8::Object::GetPrototype has been deprecated. See http://crbug.com/333672197
+#define GET_PROTOTYPE(obj) ((obj)->GetPrototypeV2())
+#else
+#define GET_PROTOTYPE(obj) ((obj)->GetPrototype())
+#endif
+
+// PropertyCallbackInfo::This() and Holder() were removed; use HolderV2().
+// Tracking bug for V8 API removals: http://crbug.com/333672197
+// V8 head has since restored Holder() and deprecated HolderV2():
+//   https://chromium.googlesource.com/v8/v8/+/main/include/v8-function-callback.h
+//   V8_INLINE Local<Object> Holder() const;
+//   V8_DEPRECATE_SOON("Use Holder().")
+//   V8_INLINE Local<Object> HolderV2() const;
+#if defined(V8_MAJOR_VERSION) && V8_MAJOR_VERSION >= 13
+#define PROPERTY_HOLDER(info) (info).HolderV2()
+#else
+#define PROPERTY_HOLDER(info) (info).This()
+#endif
+
+#define EasyIsolate v8::Isolate* isolate = v8::Isolate::GetCurrent()
+#define OnlyIsolate info.GetIsolate()
+#define OnlyContext isolate->GetCurrentContext()
+#define OnlyAddon static_cast<Addon*>(info.Data().As<v8::External>()->Value())
+#define UseIsolate v8::Isolate* isolate = OnlyIsolate
+#define UseContext v8::Local<v8::Context> ctx = OnlyContext
+#define UseAddon Addon* addon = OnlyAddon
+#define Unwrap node::ObjectWrap::Unwrap
+
+#define REQUIRE_ARGUMENT_ANY(at, var)                                          \
+	if (info.Length() <= (at()))                                               \
+		return ThrowTypeError("Expected a "#at" argument");                    \
+	var = info[at()]
+
+#define _REQUIRE_ARGUMENT(at, var, Type, message, ...)                         \
+	if (info.Length() <= (at()) || !info[at()]->Is##Type())                    \
+		return ThrowTypeError("Expected "#at" argument to be "#message);       \
+	var = (info[at()].As<v8::Type>())__VA_ARGS__
+
+#define REQUIRE_ARGUMENT_INT32(at, var)                                        \
+	_REQUIRE_ARGUMENT(at, var, Int32, a 32-bit signed integer, ->Value())
+#define REQUIRE_ARGUMENT_BOOLEAN(at, var)                                      \
+	_REQUIRE_ARGUMENT(at, var, Boolean, a boolean, ->Value())
+#define REQUIRE_ARGUMENT_STRING(at, var)                                       \
+	_REQUIRE_ARGUMENT(at, var, String, a string)
+#define REQUIRE_ARGUMENT_OBJECT(at, var)                                       \
+	_REQUIRE_ARGUMENT(at, var, Object, an object)
+#define REQUIRE_ARGUMENT_FUNCTION(at, var)                                     \
+	_REQUIRE_ARGUMENT(at, var, Function, a function)
+
+#define REQUIRE_DATABASE_OPEN(db)                                              \
+	if (!db->open)                                                             \
+		return ThrowTypeError("The database connection is not open")
+#define REQUIRE_DATABASE_NOT_BUSY(db)                                          \
+	if (db->busy)                                                              \
+		return ThrowTypeError("This database connection is busy executing a query")
+#define REQUIRE_DATABASE_NO_ITERATORS(db)                                      \
+	if (db->iterators)                                                         \
+		return ThrowTypeError("This database connection is busy executing a query")
+#define REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db)                        \
+	if (!db->unsafe_mode) {                                                    \
+		REQUIRE_DATABASE_NO_ITERATORS(db);                                     \
+	} ((void)0)
+#define REQUIRE_STATEMENT_NOT_LOCKED(stmt)                                     \
+	if (stmt->locked)                                                          \
+		return ThrowTypeError("This statement is busy executing a query")
+
+#define first() 0
+#define second() 1
+#define third() 2
+#define fourth() 3
+#define fifth() 4
+#define sixth() 5
+#define seventh() 6
+#define eighth() 7
+#define ninth() 8
+#define tenth() 9

package/vendor/better-sqlite3-win32-x64-node22/src/util/query-macros.cpp

@@ -0,0 +1,71 @@
+#define STATEMENT_BIND(handle)                                                 \
+	Binder binder(handle);                                                     \
+	if (!binder.Bind(info, info.Length(), stmt)) {                             \
+		sqlite3_clear_bindings(handle);                                        \
+		return;                                                                \
+	} ((void)0)
+
+#define STATEMENT_THROW_LOGIC()                                                \
+	db->ThrowDatabaseError();                                                  \
+	if (!bound) { sqlite3_clear_bindings(handle); }                            \
+	return
+
+#define STATEMENT_RETURN_LOGIC(return_value)                                   \
+	info.GetReturnValue().Set(return_value);                                   \
+	if (!bound) { sqlite3_clear_bindings(handle); }                            \
+	return
+
+#define STATEMENT_START_LOGIC(RETURNS_DATA_CHECK, MUTATE_CHECK)                \
+	Statement* stmt = Unwrap<Statement>(info.This());                          \
+	RETURNS_DATA_CHECK();                                                      \
+	sqlite3_stmt* handle = stmt->handle;                                       \
+	Database* db = stmt->db;                                                   \
+	REQUIRE_DATABASE_OPEN(db->GetState());                                     \
+	REQUIRE_DATABASE_NOT_BUSY(db->GetState());                                 \
+	MUTATE_CHECK();                                                            \
+	const bool bound = stmt->bound;                                            \
+	if (!bound) {                                                              \
+		STATEMENT_BIND(handle);                                                \
+	} else if (info.Length() > 0) {                                            \
+		return ThrowTypeError("This statement already has bound parameters");  \
+	} ((void)0)
+
+
+#define STATEMENT_THROW() db->GetState()->busy = false; STATEMENT_THROW_LOGIC()
+#define STATEMENT_RETURN(x) db->GetState()->busy = false; STATEMENT_RETURN_LOGIC(x)
+#define STATEMENT_START(x, y)                                                  \
+	STATEMENT_START_LOGIC(x, y);                                               \
+	db->GetState()->busy = true;                                               \
+	UseIsolate;                                                                \
+	if (db->Log(isolate, handle)) {                                            \
+		STATEMENT_THROW();                                                     \
+	} ((void)0)
+
+
+#define DOES_NOT_MUTATE() REQUIRE_STATEMENT_NOT_LOCKED(stmt)
+#define DOES_MUTATE()                                                          \
+	REQUIRE_STATEMENT_NOT_LOCKED(stmt);                                        \
+	REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db->GetState())
+#define DOES_ADD_ITERATOR()                                                    \
+	DOES_NOT_MUTATE();                                                         \
+	if (db->GetState()->iterators == USHRT_MAX)                                \
+		return ThrowRangeError("Too many active database iterators")
+#define REQUIRE_STATEMENT_RETURNS_DATA()                                       \
+	if (!stmt->returns_data)                                                   \
+		return ThrowTypeError("This statement does not return data. Use run() instead")
+#define ALLOW_ANY_STATEMENT()                                                  \
+	((void)0)
+
+
+#define _FUNCTION_START(type)                                                  \
+	type* self = static_cast<type*>(sqlite3_user_data(invocation));            \
+	v8::Isolate* isolate = self->isolate;                                      \
+	v8::HandleScope scope(isolate)
+
+#define FUNCTION_START()                                                       \
+	_FUNCTION_START(CustomFunction)
+
+#define AGGREGATE_START()                                                      \
+	_FUNCTION_START(CustomAggregate);                                          \
+	Accumulator* acc = self->GetAccumulator(invocation);                       \
+	if (acc->value.IsEmpty()) return

package/vendor/better-sqlite3-win32-x64-node22/src/util/row-builder.cpp

@@ -0,0 +1,49 @@
+class RowBuilder {
+public:
+
+	explicit RowBuilder(
+		v8::Isolate* isolate,
+		sqlite3_stmt* handle,
+		bool safe_ints
+	) :
+		isolate(isolate),
+		handle(handle),
+		column_count(-1),
+		safe_ints(safe_ints),
+		keys(isolate) {}
+
+	v8::Local<v8::Value> GetRowJS() {
+		if (column_count < 0) {
+			column_count = sqlite3_column_count(handle);
+			keys.reserve(column_count);
+			for (int i = 0; i < column_count; ++i) {
+				keys.emplace_back(
+					InternalizedFromUtf8(isolate, sqlite3_column_name(handle, i), -1)
+						.As<v8::Name>()
+				);
+			}
+		}
+
+		v8::LocalVector<v8::Value> values(isolate);
+		values.reserve(column_count);
+		for (int i = 0; i < column_count; ++i) {
+			values.emplace_back(
+				Data::GetValueJS(isolate, handle, i, safe_ints)
+			);
+		}
+
+		return v8::Object::New(isolate,
+			GET_PROTOTYPE(v8::Object::New(isolate)),
+			keys.data(),
+			values.data(),
+			column_count
+		);
+	}
+
+private:
+	v8::Isolate* isolate;
+	sqlite3_stmt* handle;
+	int column_count;
+	const bool safe_ints;
+	v8::LocalVector<v8::Name> keys;
+};

package/vendor/node-pty-fork/README.md

@@ -66,6 +66,7 @@ npm run smoke:install
 
 - `verify:tarball` 会把最新的 `.tgz` 解包到临时目录，直接检查发布包内容
 - `smoke:install` 会在临时目录里安装 tarball，并阻断任何 `node-gyp rebuild`
+- workspace 源码目录执行 `pnpm install` / `npm install` 时，`install` 脚本会主动跳过；因为源码目录默认不是正式发布包，真正的 Windows 运行时验收要显式执行 `npm run verify:runtime`
 
 ## 发布阻断条件
 

package/vendor/node-pty-fork/scripts/runtime-install-context.cjs

@@ -0,0 +1,24 @@
+"use strict";
+
+const path = require("node:path");
+
+function normalizeSegments(targetPath) {
+  return path
+    .resolve(targetPath)
+    .split(/[\\/]+/u)
+    .filter(Boolean)
+    .map((segment) => segment.toLowerCase());
+}
+
+function isInstalledUnderNodeModules(targetPath) {
+  return normalizeSegments(targetPath).includes("node_modules");
+}
+
+function isWorkspaceSourceInstall(targetPath) {
+  return !isInstalledUnderNodeModules(targetPath);
+}
+
+module.exports = {
+  isInstalledUnderNodeModules,
+  isWorkspaceSourceInstall
+};

package/vendor/node-pty-fork/scripts/verify-runtime.cjs

@@ -2,6 +2,7 @@
 
 const fs = require("node:fs");
 const path = require("node:path");
+const { isWorkspaceSourceInstall } = require("./runtime-install-context.cjs");
 
 const packageRoot = path.resolve(__dirname, "..");
 const releaseDir = path.join(packageRoot, "build", "Release");
@@ -30,6 +31,13 @@ if (process.arch !== "x64") {
   process.exit(1);
 }
 
+if (isWorkspaceSourceInstall(packageRoot)) {
+  console.log(
+    "[codingns-node-pty] 检测到源码工作区安装，跳过 install 阶段运行时校验；正式验收请显式执行 npm run verify:runtime。"
+  );
+  process.exit(0);
+}
+
 const nodeMajor = Number((process.versions.node || "").split(".")[0]);
 if (nodeMajor !== 22) {
   console.error(`[codingns-node-pty] 当前仅支持 Node 22，检测到 ${process.versions.node || "unknown"}。`);

package/vendor/node-pty-fork/scripts/verify-runtime.test.cjs

@@ -4,9 +4,39 @@ const assert = require("node:assert/strict");
 const { spawnSync } = require("node:child_process");
 const path = require("node:path");
 const test = require("node:test");
+const {
+  isInstalledUnderNodeModules,
+  isWorkspaceSourceInstall
+} = require("./runtime-install-context.cjs");
 
 const scriptPath = path.join(__dirname, "verify-runtime.cjs");
 
+test("源码工作区路径不会被误判成 node_modules 安装", () => {
+  assert.equal(
+    isInstalledUnderNodeModules("/repo/packages/node-pty-fork"),
+    false
+  );
+  assert.equal(
+    isWorkspaceSourceInstall("/repo/packages/node-pty-fork"),
+    true
+  );
+});
+
+test("node_modules 路径会命中正式安装上下文", () => {
+  assert.equal(
+    isInstalledUnderNodeModules(
+      "C:\\repo\\node_modules\\@codingns\\node-pty"
+    ),
+    true
+  );
+  assert.equal(
+    isWorkspaceSourceInstall(
+      "C:\\repo\\node_modules\\@codingns\\node-pty"
+    ),
+    false
+  );
+});
+
 test("非 Windows 环境会跳过 node-pty 运行时校验", () => {
   const result = spawnSync(process.execPath, [scriptPath], {
     encoding: "utf8"

package/vendor-src/better-sqlite3-win32-x64-node22/README.md

@@ -0,0 +1,12 @@
+# `better-sqlite3`（CodingNS Windows 受控包）
+
+这是 CodingNS 自维护的 `better-sqlite3` Windows 运行时包。
+
+目标很窄：
+
+- 只支持 `win32 + x64 + Node 22`
+- 包名保持 `better-sqlite3`，这样 npm 安装时不会再把“依赖名”和“真实包名”装成两套
+- 只给 `@jingyi0605/codingns` 的正式安装使用
+- 不接受安装阶段再回退到本机 `node-gyp rebuild`
+
+它不是通用发布包，也不是给工作区开发时直接依赖的源码包。