deepline 0.0.1 → 0.1.1

package/dist/repo/sdk/src/cli/utils.ts

@@ -0,0 +1,145 @@
+import { readFileSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { execSync } from 'node:child_process';
+import { parse } from 'csv-parse/sync';
+import { stringify } from 'csv-stringify/sync';
+import { resolveConfig } from '../config.js';
+import { HttpClient } from '../http.js';
+
+export function getAuthedHttpClient() {
+  const config = resolveConfig();
+  return { config, http: new HttpClient(config) };
+}
+
+export async function writeOutputFile(
+  filename: string,
+  content: string,
+): Promise<string> {
+  const outputDir = resolve(process.cwd(), 'deepline', 'data');
+  await mkdir(outputDir, { recursive: true });
+  const fullPath = join(outputDir, filename);
+  await writeFile(fullPath, content, 'utf-8');
+  return fullPath;
+}
+
+export function openInBrowser(url: string): void {
+  try {
+    if (process.platform === 'darwin') execSync(`open "${url}"`, { stdio: 'ignore' });
+    else if (process.platform === 'win32')
+      execSync(`start "" "${url}"`, { stdio: 'ignore' });
+    else execSync(`xdg-open "${url}"`, { stdio: 'ignore' });
+  } catch {
+    // best effort
+  }
+}
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+
+export function collectLocalEnvInfo(): Record<string, string> {
+  return {
+    os: `${process.platform} ${process.arch}`,
+    node_version: process.version,
+    home_dir: homedir(),
+  };
+}
+
+export function readCsvRows(csvPath: string): Array<Record<string, string>> {
+  const raw = readFileSync(resolve(csvPath), 'utf-8');
+  return parse(raw, {
+    columns: true,
+    skip_empty_lines: true,
+  }) as Array<Record<string, string>>;
+}
+
+export function csvStringFromRows(
+  rows: Array<Record<string, unknown>>,
+  columns?: string[],
+): string {
+  return stringify(rows, {
+    header: true,
+    ...(columns?.length ? { columns } : {}),
+  });
+}
+
+export function printJson(value: unknown): void {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+export function errorToJsonPayload(error: unknown): {
+  ok: false;
+  error: {
+    message: string;
+    code: string;
+    details?: Record<string, unknown>;
+  };
+} {
+  const message = error instanceof Error ? error.message : String(error);
+  const maybeRecord =
+    error && typeof error === 'object'
+      ? (error as Record<string, unknown>)
+      : null;
+  const code =
+    typeof maybeRecord?.code === 'string'
+      ? maybeRecord.code
+      : error instanceof SyntaxError
+        ? 'INVALID_JSON'
+        : 'CLI_ERROR';
+  const details: Record<string, unknown> = {};
+  if (typeof maybeRecord?.statusCode === 'number') {
+    details.statusCode = maybeRecord.statusCode;
+  }
+  if (typeof maybeRecord?.status === 'number') {
+    details.status = maybeRecord.status;
+  }
+  if (
+    maybeRecord?.details &&
+    typeof maybeRecord.details === 'object' &&
+    !Array.isArray(maybeRecord.details)
+  ) {
+    details.details = maybeRecord.details;
+  }
+  if (typeof maybeRecord?.cause === 'string') {
+    details.cause = maybeRecord.cause;
+  }
+  return {
+    ok: false,
+    error: {
+      message,
+      code,
+      ...(Object.keys(details).length > 0 ? { details } : {}),
+    },
+  };
+}
+
+export function printJsonError(error: unknown): void {
+  printJson(errorToJsonPayload(error));
+}
+
+export function shouldEmitJson(explicitJson = false): boolean {
+  return explicitJson || !process.stdout.isTTY;
+}
+
+export function argsWantJson(args: string[]): boolean {
+  return shouldEmitJson(args.includes('--json'));
+}
+
+export function createTimestampedName(prefix: string, extension: string): string {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  return `${prefix}-${timestamp}.${extension}`;
+}
+
+export async function writeCsvRowsFile(
+  prefix: string,
+  rows: Array<Record<string, unknown>>,
+): Promise<string> {
+  const path = await writeOutputFile(createTimestampedName(prefix, 'csv'), csvStringFromRows(rows));
+  return path;
+}
+
+export function clip(value: string, maxLength: number): string {
+  return value.length > maxLength ? `${value.slice(0, maxLength - 1)}…` : value;
+}