@agentrix/cli 0.0.2

package/dist/lib.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var logger = require('./logger-CVOTByt5.cjs');
+require('winston');
+require('chalk');
+require('node:os');
+require('node:crypto');
+require('node:fs');
+require('node:fs/promises');
+require('node:path');
+require('@agentrix/shared');
+require('path');
+require('url');
+
+
+
+exports.Machine = logger.Machine;
+exports.logger = logger.logger;
+exports.machine = logger.machine;

package/dist/lib.d.cts

@@ -0,0 +1,76 @@
+import winston from 'winston';
+import { FileHandle } from 'node:fs/promises';
+import { AgentContext, CreateTaskEventData, ResumeTaskEventData } from '@agentrix/shared';
+
+/**
+ * Winston-based logging system for agentrix CLI
+ *
+ * Design decisions:
+ * - Use Winston for robust logging with file rotation
+ * - Three logging modes:
+ *   1. console-only: CLI commands (no file logging)
+ *   2. daemon: Single daemon.log with rotation (10MB x 10 files)
+ *   3. worker: Per-task logs task-{taskId}.log with rotation (5MB x 3 files)
+ * - File output location: ~/.agentrix/logs/
+ */
+
+declare let logger: winston.Logger;
+
+interface DaemonState {
+    pid: number;
+    port: number;
+    startTime: string;
+    cliVersion: string;
+    logPath: string;
+}
+type Credentials = {
+    secret?: string;
+    token: string;
+    machineId: string;
+};
+type MachineStatePaths = {
+    rootDir: string;
+    logsDir: string;
+    settingsFile: string;
+    credentialsFile: string;
+    daemonStateFile: string;
+    daemonLockFile: string;
+};
+declare class Machine implements AgentContext {
+    readonly serverUrl: string;
+    readonly webappUrl: string;
+    readonly isDaemonProcess: boolean;
+    readonly agentrixHomeDir: string;
+    readonly agentrixWorkspaceHomeDir: string;
+    readonly agentrixAgentsHomeDir: string;
+    readonly currentCliVersion: string;
+    readonly disableCaffeinate: boolean;
+    readonly statePaths: MachineStatePaths;
+    secretKey?: Uint8Array<ArrayBufferLike>;
+    constructor();
+    generateMachineId(): string;
+    metadata(): any;
+    getStatePaths(): MachineStatePaths;
+    readCredentials(): Promise<Credentials | null>;
+    writeCredentials(credentials: Credentials): Promise<void>;
+    clearCredentials(): Promise<void>;
+    readDaemonState(): Promise<DaemonState | null>;
+    writeDaemonState(state: DaemonState): void;
+    clearDaemonState(): Promise<void>;
+    acquireDaemonLock(maxAttempts?: number, delayIncrementMs?: number): Promise<FileHandle | null>;
+    releaseDaemonLock(lockHandle: FileHandle): Promise<void>;
+    ensureDir(target: string): string;
+    resolveProjectDir(cwd: string | undefined, userId: string, taskId: string): string;
+    resolveDataDir(userId: string, taskId: string): string;
+    resolveAttachmentsDir(userId: string, taskId: string): string;
+    resolveAgentDir(agentId: string): string;
+    getInitialCommitHashPath(userId: string, taskId: string): string;
+    readInitialCommitHash(userId: string, taskId: string): Promise<string | null>;
+    writeInitialCommitHash(userId: string, taskId: string, hash: string): Promise<void>;
+    writeTaskInput(data: CreateTaskEventData | ResumeTaskEventData): void;
+    readTaskInput(userId: string, taskId: string): (CreateTaskEventData | ResumeTaskEventData);
+    getSecretKey(): Promise<Uint8Array<ArrayBufferLike> | undefined>;
+}
+declare const machine: Machine;
+
+export { Machine, logger, machine };

package/dist/lib.d.mts

@@ -0,0 +1,76 @@
+import winston from 'winston';
+import { FileHandle } from 'node:fs/promises';
+import { AgentContext, CreateTaskEventData, ResumeTaskEventData } from '@agentrix/shared';
+
+/**
+ * Winston-based logging system for agentrix CLI
+ *
+ * Design decisions:
+ * - Use Winston for robust logging with file rotation
+ * - Three logging modes:
+ *   1. console-only: CLI commands (no file logging)
+ *   2. daemon: Single daemon.log with rotation (10MB x 10 files)
+ *   3. worker: Per-task logs task-{taskId}.log with rotation (5MB x 3 files)
+ * - File output location: ~/.agentrix/logs/
+ */
+
+declare let logger: winston.Logger;
+
+interface DaemonState {
+    pid: number;
+    port: number;
+    startTime: string;
+    cliVersion: string;
+    logPath: string;
+}
+type Credentials = {
+    secret?: string;
+    token: string;
+    machineId: string;
+};
+type MachineStatePaths = {
+    rootDir: string;
+    logsDir: string;
+    settingsFile: string;
+    credentialsFile: string;
+    daemonStateFile: string;
+    daemonLockFile: string;
+};
+declare class Machine implements AgentContext {
+    readonly serverUrl: string;
+    readonly webappUrl: string;
+    readonly isDaemonProcess: boolean;
+    readonly agentrixHomeDir: string;
+    readonly agentrixWorkspaceHomeDir: string;
+    readonly agentrixAgentsHomeDir: string;
+    readonly currentCliVersion: string;
+    readonly disableCaffeinate: boolean;
+    readonly statePaths: MachineStatePaths;
+    secretKey?: Uint8Array<ArrayBufferLike>;
+    constructor();
+    generateMachineId(): string;
+    metadata(): any;
+    getStatePaths(): MachineStatePaths;
+    readCredentials(): Promise<Credentials | null>;
+    writeCredentials(credentials: Credentials): Promise<void>;
+    clearCredentials(): Promise<void>;
+    readDaemonState(): Promise<DaemonState | null>;
+    writeDaemonState(state: DaemonState): void;
+    clearDaemonState(): Promise<void>;
+    acquireDaemonLock(maxAttempts?: number, delayIncrementMs?: number): Promise<FileHandle | null>;
+    releaseDaemonLock(lockHandle: FileHandle): Promise<void>;
+    ensureDir(target: string): string;
+    resolveProjectDir(cwd: string | undefined, userId: string, taskId: string): string;
+    resolveDataDir(userId: string, taskId: string): string;
+    resolveAttachmentsDir(userId: string, taskId: string): string;
+    resolveAgentDir(agentId: string): string;
+    getInitialCommitHashPath(userId: string, taskId: string): string;
+    readInitialCommitHash(userId: string, taskId: string): Promise<string | null>;
+    writeInitialCommitHash(userId: string, taskId: string, hash: string): Promise<void>;
+    writeTaskInput(data: CreateTaskEventData | ResumeTaskEventData): void;
+    readTaskInput(userId: string, taskId: string): (CreateTaskEventData | ResumeTaskEventData);
+    getSecretKey(): Promise<Uint8Array<ArrayBufferLike> | undefined>;
+}
+declare const machine: Machine;
+
+export { Machine, logger, machine };

package/dist/lib.mjs

@@ -0,0 +1,11 @@
+export { M as Machine, l as logger, m as machine } from './logger-f691UxTg.mjs';
+import 'winston';
+import 'chalk';
+import 'node:os';
+import 'node:crypto';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:path';
+import '@agentrix/shared';
+import 'path';
+import 'url';

package/dist/logger-CVOTByt5.cjs

@@ -0,0 +1,497 @@
+'use strict';
+
+var winston = require('winston');
+var chalk = require('chalk');
+var os = require('node:os');
+var node_crypto = require('node:crypto');
+var fs = require('node:fs');
+var promises = require('node:fs/promises');
+var path = require('node:path');
+var shared = require('@agentrix/shared');
+var require$$1 = require('path');
+var url = require('url');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+var name = "@agentrix/cli";
+var version = "0.0.2";
+var description = "Mobile and Web client for Claude Code and Codex";
+var author = "agentrix.xmz.ai";
+var type = "module";
+var homepage = "https://github.com/xmz-ai/agentrix-cli";
+var bugs = "https://github.com/xmz-ai/agentrix-cli/issues";
+var repository = "xmz-ai/agentrix-cli";
+var bin = {
+	agentrix: "./bin/agentrix.mjs"
+};
+var main = "./dist/index.cjs";
+var module$1 = "./dist/index.mjs";
+var types = "./dist/index.d.cts";
+var exports$1 = {
+	".": {
+		require: {
+			types: "./dist/index.d.cts",
+			"default": "./dist/index.cjs"
+		},
+		"import": {
+			types: "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
+		}
+	},
+	"./lib": {
+		require: {
+			types: "./dist/lib.d.cts",
+			"default": "./dist/lib.cjs"
+		},
+		"import": {
+			types: "./dist/lib.d.mts",
+			"default": "./dist/lib.mjs"
+		}
+	}
+};
+var files = [
+	"dist",
+	"bin",
+	"scripts",
+	"tools",
+	"package.json"
+];
+var scripts = {
+	"why do we need to build before running tests / dev?": "We need the binary to be built so we run daemon commands which directly run the binary",
+	typecheck: "tsc --noEmit --skipLibCheck 2>&1 | (grep -v 'node_modules/effect' | grep -v 'Symbol.dispose' || true)",
+	build: "shx rm -rf dist && npx tsc --noEmit --skipLibCheck 2>&1 | (grep -v 'node_modules/effect' | grep -v 'Symbol.dispose' || true) && pkgroll",
+	prod: "node --env-file=.env ./bin/agentrix.mjs",
+	test: "yarn build && tsx --env-file .env.integration-test node_modules/.bin/vitest run",
+	dev: "yarn build && tsx --env-file .env.dev src/index.ts",
+	prepublishOnly: "yarn build && yarn test",
+	release: "release-it",
+	postinstall: "node scripts/unpack-tools.cjs",
+	lint: "eslint 'src/**/*.{js,ts}' --fix"
+};
+var pkgroll = {
+	minify: true,
+	sourcemap: false
+};
+var dependencies = {
+	"@agentrix/shared": "*",
+	"@anthropic-ai/claude-agent-sdk": "^0.1.30",
+	"@anthropic-ai/claude-code": "2.0.14",
+	"@anthropic-ai/sdk": "0.65.0",
+	"@modelcontextprotocol/sdk": "^1.15.1",
+	"@openai/codex-sdk": "^0.58.0",
+	"@stablelib/base64": "^2.0.1",
+	"@stablelib/hex": "^2.0.1",
+	"@types/cross-spawn": "^6.0.6",
+	"@types/http-proxy": "^1.17.16",
+	"@types/ps-list": "^6.2.1",
+	"@types/qrcode-terminal": "^0.12.2",
+	"@types/react": "^19.1.9",
+	"@types/tmp": "^0.2.6",
+	"@types/yargs": "^17.0.33",
+	axios: "^1.10.0",
+	chalk: "^5.4.1",
+	"cross-spawn": "^7.0.6",
+	"expo-server-sdk": "^3.15.0",
+	fastify: "^5.5.0",
+	"fastify-type-provider-zod": "4.0.2",
+	"http-proxy": "^1.18.1",
+	"http-proxy-middleware": "^3.0.5",
+	ink: "^6.1.0",
+	open: "^10.2.0",
+	"ps-list": "^8.1.1",
+	"qrcode-terminal": "^0.12.0",
+	react: "^19.1.1",
+	"simple-git": "^3.30.0",
+	"socket.io-client": "^4.8.1",
+	tar: "^7.4.3",
+	tmp: "^0.2.5",
+	tweetnacl: "^1.0.3",
+	winston: "^3.18.3",
+	"winston-daily-rotate-file": "^5.0.0",
+	yargs: "^17.7.2",
+	zod: "^3.23.8"
+};
+var devDependencies = {
+	"@eslint/compat": "^1",
+	"@types/mime-types": "^3.0.1",
+	"@types/node": ">=20",
+	"cross-env": "^10.0.0",
+	dotenv: "^16.6.1",
+	eslint: "^9",
+	"eslint-config-prettier": "^10",
+	pkgroll: "^2.14.2",
+	"release-it": "^19.0.4",
+	shx: "^0.3.3",
+	"ts-node": "^10",
+	tsx: "^4.20.3",
+	typescript: "^5",
+	vitest: "^3.2.4"
+};
+var resolutions = {
+	"whatwg-url": "14.2.0",
+	"parse-path": "7.0.3",
+	"@types/parse-path": "7.0.3"
+};
+var publishConfig = {
+	registry: "https://registry.npmjs.org"
+};
+var packageManager = "yarn@1.22.22";
+var packageJson = {
+	name: name,
+	version: version,
+	description: description,
+	author: author,
+	type: type,
+	homepage: homepage,
+	bugs: bugs,
+	repository: repository,
+	bin: bin,
+	main: main,
+	module: module$1,
+	types: types,
+	exports: exports$1,
+	files: files,
+	scripts: scripts,
+	pkgroll: pkgroll,
+	dependencies: dependencies,
+	devDependencies: devDependencies,
+	resolutions: resolutions,
+	publishConfig: publishConfig,
+	packageManager: packageManager
+};
+
+const __dirname$1 = require$$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('logger-CVOTByt5.cjs', document.baseURI).href))));
+function projectPath() {
+  const path = require$$1.resolve(__dirname$1, "..");
+  return path;
+}
+class Machine {
+  serverUrl;
+  webappUrl;
+  isDaemonProcess;
+  agentrixHomeDir;
+  agentrixWorkspaceHomeDir;
+  agentrixAgentsHomeDir;
+  currentCliVersion;
+  disableCaffeinate;
+  statePaths;
+  secretKey;
+  constructor() {
+    const args = process.argv.slice(2);
+    this.isDaemonProcess = args[0] === "daemon";
+    this.serverUrl = process.env.AGENTRIX_SERVER_URL || "https://agentrix.xmz.ai";
+    this.webappUrl = process.env.AGENTRIX_WEBAPP_URL || "https://agentrix.xmz.ai";
+    this.agentrixHomeDir = process.env.AGENTRIX_HOME_DIR ? process.env.AGENTRIX_HOME_DIR.replace(/^~/, os.homedir()) : path.join(os.homedir(), ".agentrix");
+    this.agentrixWorkspaceHomeDir = process.env.AGENTRIX_WORKSPACE_HOME_DIR ? process.env.AGENTRIX_WORKSPACE_HOME_DIR.replace(/^~/, os.homedir()) : path.join(this.agentrixHomeDir, "workspaces");
+    this.agentrixAgentsHomeDir = process.env.AGENTRIX_AGENTS_HOME_DIR ? process.env.AGENTRIX_AGENTS_HOME_DIR.replace(/^~/, os.homedir()) : path.join(this.agentrixHomeDir, "agents");
+    this.disableCaffeinate = ["true", "1", "yes"].includes(
+      (process.env.AGENTRIX_DISABLE_CAFFEINATE ?? "").toLowerCase()
+    );
+    this.currentCliVersion = packageJson.version;
+    this.ensureDir(this.agentrixHomeDir);
+    this.ensureDir(this.agentrixWorkspaceHomeDir);
+    this.ensureDir(this.agentrixAgentsHomeDir);
+    this.statePaths = {
+      rootDir: this.agentrixHomeDir,
+      logsDir: this.ensureDir(path.join(this.agentrixHomeDir, "logs")),
+      settingsFile: path.join(this.agentrixHomeDir, "settings.json"),
+      credentialsFile: path.join(this.agentrixHomeDir, "credentials.json"),
+      daemonStateFile: path.join(this.agentrixHomeDir, "daemon.state.json"),
+      daemonLockFile: path.join(this.agentrixHomeDir, "daemon.state.json.lock")
+    };
+  }
+  generateMachineId() {
+    return `machine-${node_crypto.randomUUID()}`;
+  }
+  metadata() {
+    return {
+      host: os.hostname(),
+      platform: os.platform(),
+      cliVersion: this.currentCliVersion,
+      homeDir: os.homedir(),
+      agentrixHomeDir: this.agentrixHomeDir,
+      agentrixWorkspaceHomeDir: this.agentrixWorkspaceHomeDir
+    };
+  }
+  getStatePaths() {
+    return this.statePaths;
+  }
+  async readCredentials() {
+    const paths = this.getStatePaths();
+    if (!fs.existsSync(paths.credentialsFile)) {
+      return null;
+    }
+    try {
+      const content = await promises.readFile(paths.credentialsFile, "utf8");
+      const parsed = JSON.parse(content);
+      return {
+        secret: parsed.secret,
+        token: parsed.token,
+        machineId: parsed.machineId
+      };
+    } catch {
+      return null;
+    }
+  }
+  async writeCredentials(credentials) {
+    const paths = this.getStatePaths();
+    await promises.writeFile(
+      paths.credentialsFile,
+      JSON.stringify(credentials, null, 2)
+    );
+  }
+  async clearCredentials() {
+    const paths = this.getStatePaths();
+    if (fs.existsSync(paths.credentialsFile)) {
+      await promises.unlink(paths.credentialsFile);
+    }
+  }
+  async readDaemonState() {
+    const paths = this.getStatePaths();
+    try {
+      if (!fs.existsSync(paths.daemonStateFile)) {
+        return null;
+      }
+      const content = await promises.readFile(paths.daemonStateFile, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      console.error(`[PERSISTENCE] Daemon state file corrupted: ${paths.daemonStateFile}`, error);
+      return null;
+    }
+  }
+  writeDaemonState(state) {
+    const paths = this.getStatePaths();
+    fs.writeFileSync(paths.daemonStateFile, JSON.stringify(state, null, 2), "utf-8");
+  }
+  async clearDaemonState() {
+    const paths = this.getStatePaths();
+    if (fs.existsSync(paths.daemonStateFile)) {
+      await promises.unlink(paths.daemonStateFile);
+    }
+    if (fs.existsSync(paths.daemonLockFile)) {
+      try {
+        await promises.unlink(paths.daemonLockFile);
+      } catch {
+      }
+    }
+  }
+  async acquireDaemonLock(maxAttempts = 5, delayIncrementMs = 200) {
+    const paths = this.getStatePaths();
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const handle = await promises.open(
+          paths.daemonLockFile,
+          fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY
+        );
+        await handle.writeFile(String(process.pid));
+        return handle;
+      } catch (error) {
+        if (error.code === "EEXIST") {
+          try {
+            const lockPid = fs.readFileSync(paths.daemonLockFile, "utf-8").trim();
+            if (lockPid && !Number.isNaN(Number(lockPid))) {
+              try {
+                process.kill(Number(lockPid), 0);
+              } catch {
+                fs.unlinkSync(paths.daemonLockFile);
+                continue;
+              }
+            }
+          } catch {
+          }
+        }
+        if (attempt === maxAttempts) {
+          return null;
+        }
+        const delayMs = attempt * delayIncrementMs;
+        await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+      }
+    }
+    return null;
+  }
+  async releaseDaemonLock(lockHandle) {
+    const paths = this.getStatePaths();
+    try {
+      await lockHandle.close();
+    } catch {
+    }
+    try {
+      if (fs.existsSync(paths.daemonLockFile)) {
+        fs.unlinkSync(paths.daemonLockFile);
+      }
+    } catch {
+    }
+  }
+  ensureDir(target) {
+    if (!fs.existsSync(target)) {
+      fs.mkdirSync(target, { recursive: true });
+    }
+    return target;
+  }
+  resolveProjectDir(cwd, userId, taskId) {
+    if (cwd) {
+      return this.ensureDir(cwd.replace(/^~/, os.homedir()));
+    }
+    const workspaceDir = path.join(this.agentrixWorkspaceHomeDir, "users", userId, taskId, "project");
+    return this.ensureDir(workspaceDir);
+  }
+  resolveDataDir(userId, taskId) {
+    const dataDir = path.join(this.agentrixWorkspaceHomeDir, "users", userId, taskId, "data");
+    return this.ensureDir(dataDir);
+  }
+  resolveAttachmentsDir(userId, taskId) {
+    const attachmentsDir = path.join(this.resolveDataDir(userId, taskId), "attachments");
+    return this.ensureDir(attachmentsDir);
+  }
+  resolveAgentDir(agentId) {
+    return path.join(this.agentrixAgentsHomeDir, agentId);
+  }
+  getInitialCommitHashPath(userId, taskId) {
+    return path.join(this.resolveDataDir(userId, taskId), "initial-commit-hash.txt");
+  }
+  async readInitialCommitHash(userId, taskId) {
+    const path = this.getInitialCommitHashPath(userId, taskId);
+    if (!fs.existsSync(path)) {
+      return null;
+    }
+    try {
+      const content = await promises.readFile(path, "utf-8");
+      return content.trim();
+    } catch {
+      return null;
+    }
+  }
+  async writeInitialCommitHash(userId, taskId, hash) {
+    const path = this.getInitialCommitHashPath(userId, taskId);
+    await promises.writeFile(path, hash);
+  }
+  writeTaskInput(data) {
+    const path$1 = this.resolveDataDir(data.userId, data.taskId);
+    const inputFile = path.join(path$1, "input.json");
+    fs.writeFileSync(inputFile, JSON.stringify(data, null, 2));
+  }
+  readTaskInput(userId, taskId) {
+    const path$1 = this.resolveDataDir(userId, taskId);
+    const inputFile = path.join(path$1, "input.json");
+    if (!fs.existsSync(inputFile)) {
+      throw new Error(`Task input file does not exist: ${inputFile}`);
+    }
+    const content = fs.readFileSync(inputFile, "utf-8");
+    return JSON.parse(content);
+  }
+  async getSecretKey() {
+    if (this.secretKey) {
+      return this.secretKey;
+    }
+    const credentials = await this.readCredentials();
+    if (credentials && credentials.secret) {
+      const keyPair = await shared.createKeyPair(credentials.secret);
+      this.secretKey = keyPair.secretKey;
+    }
+    return this.secretKey;
+  }
+}
+const machine = new Machine();
+shared.setAgentContext(machine);
+
+const consoleFormat = winston.format.printf(({ level, message, timestamp, ...meta }) => {
+  const timeStr = new Date(timestamp).toLocaleTimeString("en-US", {
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    fractionalSecondDigits: 3
+  });
+  let coloredLevel = level;
+  switch (level) {
+    case "error":
+      coloredLevel = chalk.red(level.toUpperCase());
+      break;
+    case "warn":
+      coloredLevel = chalk.yellow(level.toUpperCase());
+      break;
+    case "info":
+      coloredLevel = chalk.blue(level.toUpperCase());
+      break;
+    case "debug":
+      coloredLevel = chalk.gray(level.toUpperCase());
+      break;
+  }
+  const metaStr = Object.keys(meta).length > 0 ? " " + JSON.stringify(meta) : "";
+  return `[${timeStr}] ${coloredLevel}: ${message}${metaStr}`;
+});
+const fileFormat = winston.format.printf(({ level, message, timestamp, ...meta }) => {
+  const metaStr = Object.keys(meta).length > 0 ? " " + JSON.stringify(meta) : "";
+  return `[${timestamp}] ${level.toUpperCase()}: ${message}${metaStr}`;
+});
+function createLogger(context) {
+  const logsDir = machine.getStatePaths().logsDir;
+  const level = process.env.DEBUG ? "debug" : "info";
+  if (context.type === "console-only") {
+    return winston.createLogger({
+      level,
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        consoleFormat
+      ),
+      transports: [
+        new winston.transports.Console()
+      ]
+    });
+  }
+  const filename = context.type === "daemon" ? "daemon.log" : `task-${context.taskId}.log`;
+  const maxsize = 100 * 1024 * 1024;
+  const maxFiles = context.type === "daemon" ? 3 : 1;
+  const transports = [
+    new winston.transports.File({
+      filename,
+      dirname: logsDir,
+      zippedArchive: true,
+      maxsize,
+      maxFiles,
+      tailable: true,
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        fileFormat
+      )
+    })
+  ];
+  if (process.env.DEBUG) {
+    transports.push(
+      new winston.transports.Console({
+        format: winston.format.combine(
+          winston.format.timestamp(),
+          consoleFormat
+        )
+      })
+    );
+  }
+  return winston.createLogger({
+    level,
+    transports
+  });
+}
+let logger = createLogger({ type: "console-only" });
+function getLogPath(context) {
+  const logsDir = machine.getStatePaths().logsDir;
+  if (context.type === "console-only") {
+    return "";
+  }
+  const filename = context.type === "daemon" ? "daemon.log" : `task-${context.taskId}.log`;
+  return path.join(logsDir, filename);
+}
+
+var logger$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createLogger: createLogger,
+  getLogPath: getLogPath,
+  logger: logger
+});
+
+exports.Machine = Machine;
+exports.createLogger = createLogger;
+exports.getLogPath = getLogPath;
+exports.logger = logger;
+exports.logger$1 = logger$1;
+exports.machine = machine;
+exports.packageJson = packageJson;
+exports.projectPath = projectPath;