toolcraft 0.0.27 → 0.0.33

package/node_modules/@poe-code/process-runner/dist/host/host-runner.js

@@ -1,9 +1,11 @@
 import { spawn as spawnChildProcess } from "node:child_process";
 export function createHostRunner(options = {}) {
-    const detachedByDefault = options.detached === true;
+    const runnerOptions = normalizeHostRunnerOptions(options);
+    const detachedByDefault = runnerOptions.detached === true;
     return {
         name: "host",
-        exec(spec) {
+        exec(inputSpec) {
+            const spec = normalizeRunSpec(inputSpec);
             if (spec.signal?.aborted === true) {
                 return {
                     pid: null,
@@ -21,12 +23,12 @@ export function createHostRunner(options = {}) {
             const stdio = stdinMode === "inherit" && stdoutMode === "inherit" && stderrMode === "inherit"
                 ? "inherit"
                 : [stdinMode, stdoutMode, stderrMode];
-            const child = spawnChildProcess(spec.command, spec.args ?? [], {
+            const child = spawnChildProcess(spec.command, spec.args ?? [], createNullRecord({
                 cwd: spec.cwd,
                 env: spec.env,
                 stdio,
                 ...(killProcessGroup ? { detached: true } : {})
-            });
+            }));
             if (killProcessGroup) {
                 child.unref();
             }
@@ -75,6 +77,38 @@ export function createHostRunner(options = {}) {
         }
     };
 }
+function normalizeHostRunnerOptions(options) {
+    return createNullRecord({
+        ...optionalOwnProperty(options, "detached")
+    });
+}
+function normalizeRunSpec(spec) {
+    return createNullRecord({
+        command: getOwnProperty(spec, "command"),
+        ...optionalOwnProperty(spec, "args"),
+        ...optionalOwnProperty(spec, "cwd"),
+        ...optionalOwnProperty(spec, "env"),
+        ...optionalOwnProperty(spec, "stdin"),
+        ...optionalOwnProperty(spec, "stdout"),
+        ...optionalOwnProperty(spec, "stderr"),
+        ...optionalOwnProperty(spec, "tty"),
+        ...optionalOwnProperty(spec, "signal"),
+        ...optionalOwnProperty(spec, "killProcessGroup")
+    });
+}
+function optionalOwnProperty(value, name) {
+    const property = getOwnProperty(value, name);
+    return property === undefined ? {} : { [name]: property };
+}
+function getOwnProperty(value, name) {
+    return hasOwnProperty(value, name) ? value[name] : undefined;
+}
+function hasOwnProperty(value, name) {
+    return Object.prototype.hasOwnProperty.call(value, name);
+}
+function createNullRecord(value) {
+    return Object.assign(Object.create(null), value);
+}
 function bindAbortSignal(signal, onAbort) {
     if (signal === undefined) {
         return () => { };

package/node_modules/@poe-code/process-runner/dist/workspace-transfer.js

@@ -496,8 +496,14 @@ function stripSlashes(value) {
     return value.slice(start, end);
 }
 function isNotFoundError(error) {
-    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+    return hasOwnErrorCode(error, "ENOENT");
 }
 function isAlreadyExistsError(error) {
-    return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+    return hasOwnErrorCode(error, "EEXIST");
+}
+function hasOwnErrorCode(error, code) {
+    return (typeof error === "object" &&
+        error !== null &&
+        Object.prototype.hasOwnProperty.call(error, "code") &&
+        error.code === code);
 }

package/node_modules/@poe-code/task-list/dist/backends/gh-issues-sync.js

@@ -328,20 +328,23 @@ function isExactStatusField(field) {
 function isStatusOption(value) {
     return (typeof value === "object" &&
         value !== null &&
-        "id" in value &&
+        hasOwnProperty(value, "id") &&
         typeof value.id === "string" &&
-        "name" in value &&
+        hasOwnProperty(value, "name") &&
         typeof value.name === "string" &&
-        (!("color" in value) || typeof value.color === "string") &&
-        (!("description" in value) || typeof value.description === "string"));
+        (!hasOwnProperty(value, "color") || typeof value.color === "string") &&
+        (!hasOwnProperty(value, "description") || typeof value.description === "string"));
 }
 function isStatusField(value) {
     return (typeof value === "object" &&
         value !== null &&
-        "id" in value &&
+        hasOwnProperty(value, "id") &&
         typeof value.id === "string" &&
-        (!("name" in value) || typeof value.name === "string") &&
-        "options" in value &&
+        (!hasOwnProperty(value, "name") || typeof value.name === "string") &&
+        hasOwnProperty(value, "options") &&
         Array.isArray(value.options) &&
         value.options.every(isStatusOption));
 }
+function hasOwnProperty(value, name) {
+    return Object.prototype.hasOwnProperty.call(value, name);
+}

package/node_modules/@poe-code/task-list/dist/backends/markdown-dir.js

@@ -139,29 +139,36 @@ function readFrontmatter(frontmatterContent, filePath) {
     return parsed;
 }
 function assertValidTaskRecord(frontmatter, filePath, validStates) {
-    if ("$schema" in frontmatter && frontmatter.$schema !== TASK_SCHEMA_ID) {
+    if (hasOwnTaskField(frontmatter, "$schema") && frontmatter.$schema !== TASK_SCHEMA_ID) {
         throw malformedTask(filePath, "$schema");
     }
-    if ("kind" in frontmatter && frontmatter.kind !== TASK_KIND) {
+    if (hasOwnTaskField(frontmatter, "kind") && frontmatter.kind !== TASK_KIND) {
         throw malformedTask(filePath, "kind");
     }
-    if ("version" in frontmatter) {
+    if (hasOwnTaskField(frontmatter, "version")) {
         if (typeof frontmatter.version !== "number" ||
             !Number.isInteger(frontmatter.version) ||
             frontmatter.version !== TASK_VERSION) {
             throw malformedTask(filePath, "version");
         }
     }
-    if (typeof frontmatter.name !== "string" || frontmatter.name.length === 0) {
+    if (!hasOwnTaskField(frontmatter, "name") ||
+        typeof frontmatter.name !== "string" ||
+        frontmatter.name.length === 0) {
         throw malformedTask(filePath, "name");
     }
-    if (typeof frontmatter.state !== "string" || !validStates.has(frontmatter.state)) {
+    if (!hasOwnTaskField(frontmatter, "state") ||
+        typeof frontmatter.state !== "string" ||
+        !validStates.has(frontmatter.state)) {
         throw malformedTask(filePath, "state");
     }
-    if ("description" in frontmatter && typeof frontmatter.description !== "string") {
+    if (hasOwnTaskField(frontmatter, "description") && typeof frontmatter.description !== "string") {
         throw malformedTask(filePath, "description");
     }
 }
+function hasOwnTaskField(frontmatter, key) {
+    return Object.prototype.hasOwnProperty.call(frontmatter, key);
+}
 function reservedFrontmatterKeys(mode) {
     return mode === "passthrough" ? PASSTHROUGH_RESERVED_FRONTMATTER_KEYS : RESERVED_FRONTMATTER_KEYS;
 }

package/node_modules/@poe-code/task-list/dist/backends/utils.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import path from "node:path";
 export function compareCreated(left, right) {
     const leftCreated = typeof left.raw.created === "string" ? left.raw.created : "";
@@ -20,11 +21,10 @@ export function applyOrder(entries, order) {
     }
     return entries.map((entry) => entry.task);
 }
-let tmpFileCounter = 0;
 export function hasErrorCode(error, code) {
     return (!!error &&
         typeof error === "object" &&
-        "code" in error &&
+        Object.prototype.hasOwnProperty.call(error, "code") &&
         error.code === code);
 }
 export function isRecord(value) {
@@ -78,20 +78,24 @@ export async function rejectSymbolicLinkComponents(fs, filePath) {
     }
 }
 export async function writeAtomically(fs, filePath, content) {
-    const tempPath = `${filePath}.tmp-${process.pid}-${tmpFileCounter}`;
-    tmpFileCounter += 1;
+    const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    let tempCreated = false;
     await fs.mkdir(path.dirname(filePath), { recursive: true });
     try {
         await fs.writeFile(tempPath, content, { encoding: "utf8", flag: "wx" });
+        tempCreated = true;
         await fs.rename(tempPath, filePath);
+        tempCreated = false;
     }
     catch (error) {
-        try {
-            await fs.unlink(tempPath);
-        }
-        catch (unlinkError) {
-            if (!hasErrorCode(unlinkError, "ENOENT")) {
-                throw unlinkError;
+        if (tempCreated || !hasErrorCode(error, "EEXIST")) {
+            try {
+                await fs.unlink(tempPath);
+            }
+            catch (unlinkError) {
+                if (!hasErrorCode(unlinkError, "ENOENT")) {
+                    throw unlinkError;
+                }
             }
         }
         throw error;
@@ -106,6 +110,7 @@ export async function withFileLock(fs, lockPath, operation) {
         }
         catch (error) {
             if (!hasErrorCode(error, "EEXIST")) {
+                await fs.unlink(lockPath).catch(() => undefined);
                 throw error;
             }
             if (await removeAbandonedLock(fs, lockPath)) {

package/node_modules/@poe-code/task-list/dist/backends/yaml-file.js

@@ -50,7 +50,8 @@ function parseQualifiedId(qualifiedId) {
     };
 }
 function descriptionFromTaskRecord(taskRecord) {
-    return typeof taskRecord.description === "string" ? taskRecord.description : "";
+    const description = getOwnEntry(taskRecord, "description");
+    return typeof description === "string" ? description : "";
 }
 function metadataFromTaskRecord(taskRecord) {
     const metadata = Object.create(null);
@@ -66,8 +67,8 @@ function createTask(list, id, taskRecord, sourcePath) {
         list,
         id,
         qualifiedId: `${list}/${id}`,
-        name: taskRecord.name,
-        state: taskRecord.state,
+        name: getOwnEntry(taskRecord, "name"),
+        state: getOwnEntry(taskRecord, "state"),
         description: descriptionFromTaskRecord(taskRecord),
         metadata: metadataFromTaskRecord(taskRecord),
         ...(sourcePath !== undefined && { sourcePath: path.resolve(sourcePath) })
@@ -163,18 +164,19 @@ function assertValidStoreRecord(store, filePath) {
     if (!isRecord(store)) {
         throw malformedStore(filePath, "store");
     }
-    if (store.$schema !== STORE_SCHEMA_ID) {
+    if (getOwnEntry(store, "$schema") !== STORE_SCHEMA_ID) {
         throw malformedStore(filePath, "$schema");
     }
-    if (store.kind !== STORE_KIND) {
+    if (getOwnEntry(store, "kind") !== STORE_KIND) {
         throw malformedStore(filePath, "kind");
     }
-    if (typeof store.version !== "number" ||
-        !Number.isInteger(store.version) ||
-        store.version !== STORE_VERSION) {
+    const version = getOwnEntry(store, "version");
+    if (typeof version !== "number" ||
+        !Number.isInteger(version) ||
+        version !== STORE_VERSION) {
         throw malformedStore(filePath, "version");
     }
-    if (!isRecord(store.lists)) {
+    if (!isRecord(getOwnEntry(store, "lists"))) {
         throw malformedStore(filePath, "lists");
     }
 }
@@ -182,31 +184,45 @@ function assertValidTaskRecord(taskRecord, list, id, validStates) {
     if (!isRecord(taskRecord)) {
         throw malformedTask(list, id, "task");
     }
-    if ("$schema" in taskRecord && taskRecord.$schema !== TASK_SCHEMA_ID) {
+    if (hasOwnTaskField(taskRecord, "$schema") && getOwnEntry(taskRecord, "$schema") !== TASK_SCHEMA_ID) {
         throw malformedTask(list, id, "$schema");
     }
-    if ("kind" in taskRecord && taskRecord.kind !== TASK_KIND) {
+    if (hasOwnTaskField(taskRecord, "kind") && getOwnEntry(taskRecord, "kind") !== TASK_KIND) {
         throw malformedTask(list, id, "kind");
     }
-    if ("version" in taskRecord) {
-        if (typeof taskRecord.version !== "number" ||
-            !Number.isInteger(taskRecord.version) ||
-            taskRecord.version !== TASK_VERSION) {
+    if (hasOwnTaskField(taskRecord, "version")) {
+        const version = getOwnEntry(taskRecord, "version");
+        if (typeof version !== "number" ||
+            !Number.isInteger(version) ||
+            version !== TASK_VERSION) {
             throw malformedTask(list, id, "version");
         }
     }
-    if (typeof taskRecord.name !== "string" || taskRecord.name.length === 0) {
+    const name = getOwnEntry(taskRecord, "name");
+    if (!hasOwnTaskField(taskRecord, "name") ||
+        typeof name !== "string" ||
+        name.length === 0) {
         throw malformedTask(list, id, "name");
     }
-    if (typeof taskRecord.state !== "string" || !validStates.has(taskRecord.state)) {
+    const state = getOwnEntry(taskRecord, "state");
+    if (!hasOwnTaskField(taskRecord, "state") ||
+        typeof state !== "string" ||
+        !validStates.has(state)) {
         throw malformedTask(list, id, "state");
     }
-    if ("description" in taskRecord && typeof taskRecord.description !== "string") {
+    if (hasOwnTaskField(taskRecord, "description") &&
+        typeof getOwnEntry(taskRecord, "description") !== "string") {
         throw malformedTask(list, id, "description");
     }
 }
+function hasOwnTaskField(taskRecord, key) {
+    return Object.prototype.hasOwnProperty.call(taskRecord, key);
+}
+function getOwnEntry(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;
+}
 function validateStoreEntries(store, filePath, validStates) {
-    const lists = store.lists;
+    const lists = getOwnEntry(store, "lists");
     if (!isRecord(lists)) {
         throw malformedStore(filePath, "lists");
     }
@@ -247,10 +263,11 @@ async function readStore(fs, filePath, validStates) {
     };
 }
 function getListsRecord(store) {
-    return store.lists;
+    const lists = getOwnEntry(store, "lists");
+    return isRecord(lists) ? lists : {};
 }
 function getListRecord(store, list) {
-    const listRecord = getListsRecord(store)[list];
+    const listRecord = getOwnEntry(getListsRecord(store), list);
     return isRecord(listRecord) ? listRecord : undefined;
 }
 function getTaskRecord(store, list, id) {
@@ -546,7 +563,7 @@ export async function yamlFileBackend(deps) {
         const result = [];
         const listNames = sortStrings(Object.keys(getListsRecord(store)));
         for (const listName of listNames) {
-            const listRecord = getListsRecord(store)[listName];
+            const listRecord = getOwnEntry(getListsRecord(store), listName);
             if (!isRecord(listRecord))
                 continue;
             const entries = Object.entries(listRecord)

package/node_modules/@poe-code/task-list/dist/move.js

@@ -115,7 +115,7 @@ async function applyState(tasks, created, events) {
     return task;
 }
 function readOnlySourceOptions(options) {
-    if (!("create" in options)) {
+    if (!hasOwnProperty(options, "create")) {
         return options;
     }
     return { ...options, create: false };
@@ -213,3 +213,6 @@ function createTokenBucket(rate) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function hasOwnProperty(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}

package/node_modules/@poe-code/task-list/dist/open.js

@@ -13,48 +13,70 @@ function createDefaultFs() {
     return fsPromises;
 }
 export async function openTaskList(options) {
-    switch (options.type) {
+    const type = getOwnProperty(options, "type");
+    switch (type) {
         case "markdown-dir":
         case "yaml-file":
             return openFileBackend(options);
         case "gh-issues":
             return openGhIssuesBackend(options);
         default:
-            throw new Error(`Unknown task list backend type "${options.type}".`);
+            throw new Error(`Unknown task list backend type "${String(type)}".`);
     }
 }
 async function openFileBackend(options) {
-    const factory = backendFactories[options.type];
-    const stateMachine = resolveStateMachine(options.stateMachine);
+    const type = getOwnProperty(options, "type");
+    const factory = backendFactories[type];
+    const stateMachine = resolveStateMachine(getOwnProperty(options, "stateMachine"));
     validateMachine(stateMachine);
-    const markdownOptions = options.type === "markdown-dir" ? options : undefined;
+    const markdownOptions = type === "markdown-dir" ? options : undefined;
+    const defaults = getOwnProperty(options, "defaults");
     const deps = {
-        path: options.path,
+        path: getOwnProperty(options, "path"),
         defaults: {
-            metadata: { ...(options.defaults?.metadata ?? {}) }
+            metadata: readDefaultMetadata(defaults)
         },
-        singleList: markdownOptions?.singleList,
-        frontmatterMode: markdownOptions?.frontmatterMode ?? "strict",
-        create: options.create ?? false,
-        fs: options.fs ?? createDefaultFs(),
+        singleList: markdownOptions === undefined
+            ? undefined
+            : getOwnProperty(markdownOptions, "singleList"),
+        frontmatterMode: markdownOptions === undefined
+            ? "strict"
+            : (getOwnProperty(markdownOptions, "frontmatterMode") ?? "strict"),
+        create: getOwnProperty(options, "create") ?? false,
+        fs: getOwnProperty(options, "fs") ?? createDefaultFs(),
         stateMachine
     };
     return factory(deps);
 }
 async function openGhIssuesBackend(options) {
-    const token = await resolveAuth({ explicitToken: options.auth?.token });
+    const auth = getOwnProperty(options, "auth");
+    const explicitToken = auth && hasOwnProperty(auth, "token") ? auth.token : undefined;
     const endpoint = resolveEndpoint();
+    const defaults = getOwnProperty(options, "defaults");
     return ghIssuesBackend({
-        repo: options.repo,
-        project: options.project,
-        filter: options.filter,
-        state: options.state,
-        stateMachine: options.stateMachine,
+        repo: getOwnProperty(options, "repo"),
+        project: getOwnProperty(options, "project"),
+        filter: getOwnProperty(options, "filter"),
+        state: getOwnProperty(options, "state"),
+        stateMachine: getOwnProperty(options, "stateMachine"),
         defaults: {
-            metadata: { ...(options.defaults?.metadata ?? {}) }
+            metadata: readDefaultMetadata(defaults)
         },
-        token,
+        token: await resolveAuth({ explicitToken }),
         endpoint,
-        fetch: options.fetch
+        fetch: getOwnProperty(options, "fetch")
     });
 }
+function readDefaultMetadata(defaults) {
+    const metadata = defaults === undefined ? undefined : getOwnProperty(defaults, "metadata");
+    return isRecord(metadata) ? { ...metadata } : {};
+}
+function getOwnProperty(value, name) {
+    return hasOwnProperty(value, name) ? value[name] : undefined;
+}
+function hasOwnProperty(value, name) {
+    return Object.prototype.hasOwnProperty.call(value, name);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/node_modules/@poe-code/task-list/dist/state-machine.js

@@ -14,27 +14,27 @@ export function validateMachine(machine) {
     if (!isRecord(machine)) {
         throw new TypeError("State machine must be an object.");
     }
-    if (!isStateList(machine.states)) {
+    if (!hasOwnRecordField(machine, "states") || !isStateList(machine.states)) {
         throw new TypeError("State machine states must be a string array.");
     }
     const states = new Set(machine.states);
-    if (typeof machine.initial !== "string") {
+    if (!hasOwnRecordField(machine, "initial") || typeof machine.initial !== "string") {
         throw new TypeError("State machine initial must be a string.");
     }
     if (!states.has(machine.initial)) {
         throw new Error(`Initial state "${machine.initial}" is not declared.`);
     }
-    if (!isRecord(machine.events)) {
+    if (!hasOwnRecordField(machine, "events") || !isRecord(machine.events)) {
         throw new TypeError("State machine events must be an object.");
     }
     for (const [eventName, event] of Object.entries(machine.events)) {
         if (!isRecord(event)) {
             throw new TypeError(`Event "${eventName}" must be an object.`);
         }
-        if (event.from !== "*" && !isStateList(event.from)) {
+        if (!hasOwnRecordField(event, "from") || (event.from !== "*" && !isStateList(event.from))) {
             throw new TypeError(`Event "${eventName}" has an invalid "from" definition.`);
         }
-        if (typeof event.to !== "string") {
+        if (!hasOwnRecordField(event, "to") || typeof event.to !== "string") {
             throw new TypeError(`Event "${eventName}" target state must be a string.`);
         }
         if (!states.has(event.to)) {
@@ -49,6 +49,9 @@ export function validateMachine(machine) {
         }
     }
 }
+function hasOwnRecordField(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
 export function eventsFromState(machine, fromState) {
     const events = [];
     for (const [eventName, event] of Object.entries(machine.events)) {

package/node_modules/auth-store/dist/create-secret-store.js

@@ -27,7 +27,7 @@ export function createSecretStore(input) {
 }
 function resolveBackend(input) {
     const envVar = input.backendEnvVar ?? DEFAULT_BACKEND_ENV_VAR;
-    const configuredBackend = input.backend ?? input.env?.[envVar] ?? process.env[envVar];
+    const configuredBackend = input.backend ?? getOwnEnvValue(input.env, envVar) ?? getOwnEnvValue(process.env, envVar);
     if (configuredBackend === "keychain") {
         return "keychain";
     }
@@ -36,3 +36,8 @@ function resolveBackend(input) {
     }
     throw new Error(`Unsupported auth store backend: ${configuredBackend}`);
 }
+function getOwnEnvValue(env, key) {
+    return env !== undefined && Object.prototype.hasOwnProperty.call(env, key)
+        ? env[key]
+        : undefined;
+}

package/node_modules/auth-store/dist/encrypted-file-store.d.ts

@@ -42,6 +42,6 @@ export declare class EncryptedFileStore implements SecretStore {
     get(): Promise<string | null>;
     set(value: string): Promise<void>;
     delete(): Promise<void>;
-    private assertRegularCredentialPath;
+    private assertCredentialPathHasNoSymbolicLinks;
     private getEncryptionKey;
 }