@gokiteam/goki-dev 0.2.0

package/cli/secrets/SecretsManager.js

@@ -0,0 +1,255 @@
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import { keyring } from '@zowe/secrets-for-zowe-sdk'
+import { BiometricAuth } from './BiometricAuth.js'
+
+const SERVICE_NAME = 'goki-secrets'
+const CONFIG_DIR = path.join(os.homedir(), '.goki-dev')
+const INDEX_FILE = 'secrets-index.json'
+const INDEX_PATH = path.join(CONFIG_DIR, INDEX_FILE)
+
+export class SecretsManager {
+  constructor ({ projectDir, projectName, configDir }) {
+    this._projectDir = projectDir || null
+    this._projectName = projectName || null
+    this._configDir = configDir || CONFIG_DIR
+    this._cache = new Map()
+    this._unlocked = false
+  }
+
+  static async create (options = {}) {
+    const startDir = options.projectDir || process.cwd()
+    const detected = SecretsManager.detectProject(startDir)
+    return new SecretsManager({
+      projectDir: detected?.dir || null,
+      projectName: detected?.name || null,
+      configDir: CONFIG_DIR
+    })
+  }
+
+  async unlock () {
+    const prefs = BiometricAuth.loadPreferences()
+    const auth = new BiometricAuth(prefs)
+    await auth.authenticate()
+    const index = this._readIndex()
+    for (const entry of index.secrets) {
+      // Only load global secrets and secrets for the current project
+      if (entry.scope === 'project' && entry.project !== this._projectName) continue
+      const accountKey = this._buildAccountKey(entry.key, entry.scope, entry.project)
+      try {
+        const value = await keyring.getPassword(SERVICE_NAME, accountKey)
+        if (value !== null && value !== undefined) {
+          this._cache.set(accountKey, value)
+        }
+      } catch {
+        // Secret may have been removed from keychain outside this tool
+      }
+    }
+    this._unlocked = true
+  }
+
+  get projectName () {
+    return this._projectName
+  }
+
+  get projectDir () {
+    return this._projectDir
+  }
+
+  async set (key, value, options = {}) {
+    const scope = this._resolveScope(options.scope)
+    const project = scope === 'project' ? this._projectName : null
+    if (scope === 'project' && !project) {
+      throw new Error('Cannot set project-scoped secret: no project detected')
+    }
+    const accountKey = this._buildAccountKey(key, scope, project)
+    await keyring.setPassword(SERVICE_NAME, accountKey, value)
+    this._cache.set(accountKey, value)
+    this._updateIndexEntry(key, scope, project, options.description)
+  }
+
+  get (key) {
+    if (this._projectName) {
+      const projectKey = this._buildAccountKey(key, 'project', this._projectName)
+      if (this._cache.has(projectKey)) {
+        return this._cache.get(projectKey)
+      }
+    }
+    const globalKey = this._buildAccountKey(key, 'global', null)
+    if (this._cache.has(globalKey)) {
+      return this._cache.get(globalKey)
+    }
+    return undefined
+  }
+
+  async delete (key, options = {}) {
+    const scope = this._resolveScope(options.scope)
+    const project = scope === 'project' ? this._projectName : null
+    if (scope === 'project' && !project) {
+      throw new Error('Cannot delete project-scoped secret: no project detected')
+    }
+    const accountKey = this._buildAccountKey(key, scope, project)
+    try {
+      await keyring.deletePassword(SERVICE_NAME, accountKey)
+    } catch {
+      // Already deleted or never existed
+    }
+    this._cache.delete(accountKey)
+    this._removeIndexEntry(key, scope, project)
+  }
+
+  list (options = {}) {
+    const index = this._readIndex()
+    if (options.scope) {
+      return index.secrets.filter(entry => {
+        if (entry.scope !== options.scope) return false
+        if (entry.scope === 'project' && entry.project !== this._projectName) return false
+        return true
+      })
+    }
+    return index.secrets.filter(entry => {
+      if (entry.scope === 'global') return true
+      if (entry.scope === 'project' && entry.project === this._projectName) return true
+      return false
+    })
+  }
+
+  getEnvMap () {
+    const env = {}
+    const index = this._readIndex()
+    for (const entry of index.secrets) {
+      if (entry.scope !== 'global') continue
+      const accountKey = this._buildAccountKey(entry.key, 'global', null)
+      if (this._cache.has(accountKey)) {
+        env[entry.key] = this._cache.get(accountKey)
+      }
+    }
+    if (this._projectName) {
+      for (const entry of index.secrets) {
+        if (entry.scope !== 'project' || entry.project !== this._projectName) continue
+        const accountKey = this._buildAccountKey(entry.key, 'project', entry.project)
+        if (this._cache.has(accountKey)) {
+          env[entry.key] = this._cache.get(accountKey)
+        }
+      }
+    }
+    return env
+  }
+
+  getGlobalSecrets () {
+    const env = {}
+    const index = this._readIndex()
+    for (const entry of index.secrets) {
+      if (entry.scope !== 'global') continue
+      const accountKey = this._buildAccountKey(entry.key, 'global', null)
+      if (this._cache.has(accountKey)) {
+        env[entry.key] = this._cache.get(accountKey)
+      }
+    }
+    return env
+  }
+
+  static detectProject (startDir) {
+    let dir = path.resolve(startDir)
+    const root = path.parse(dir).root
+    while (dir !== root) {
+      const pkgPath = path.join(dir, 'package.json')
+      if (fs.existsSync(pkgPath)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+          if (pkg.name) {
+            const name = pkg.name.replace(/^@[^/]+\//, '')
+            return { name, dir, source: 'package.json' }
+          }
+        } catch {
+          // Malformed package.json, skip
+        }
+      }
+      const configPath = path.join(dir, '.dev-tools', 'config.js')
+      if (fs.existsSync(configPath)) {
+        try {
+          const content = fs.readFileSync(configPath, 'utf-8')
+          const nameMatch = content.match(/name\s*:\s*['"]([^'"]+)['"]/)
+          if (nameMatch) {
+            return { name: nameMatch[1], dir, source: '.dev-tools/config.js' }
+          }
+        } catch {
+          // Skip
+        }
+      }
+      dir = path.dirname(dir)
+    }
+    return null
+  }
+
+  loadSecretsConfig (configDir) {
+    const configPath = path.join(configDir || this._projectDir, '.dev-tools', 'config.js')
+    if (!fs.existsSync(configPath)) return null
+    try {
+      // Note: dynamic import must be awaited by caller
+      return import(configPath).then(m => m.default?.secrets || null)
+    } catch {
+      return null
+    }
+  }
+
+  _resolveScope (explicitScope) {
+    if (explicitScope) return explicitScope
+    return this._projectName ? 'project' : 'global'
+  }
+
+  _buildAccountKey (key, scope, project) {
+    if (scope === 'project') {
+      return `project:${project}:${key}`
+    }
+    return `global:${key}`
+  }
+
+  _readIndex () {
+    if (!fs.existsSync(INDEX_PATH)) {
+      return { version: 1, secrets: [] }
+    }
+    try {
+      const content = fs.readFileSync(INDEX_PATH, 'utf-8')
+      return JSON.parse(content)
+    } catch {
+      return { version: 1, secrets: [] }
+    }
+  }
+
+  _writeIndex (index) {
+    fs.mkdirSync(this._configDir, { recursive: true })
+    fs.writeFileSync(INDEX_PATH, JSON.stringify(index, null, 2) + '\n')
+  }
+
+  _updateIndexEntry (key, scope, project, description) {
+    const index = this._readIndex()
+    const now = new Date().toISOString()
+    const existing = index.secrets.find(
+      e => e.key === key && e.scope === scope && e.project === (project || null)
+    )
+    if (existing) {
+      existing.updatedAt = now
+      if (description !== undefined) existing.description = description
+    } else {
+      index.secrets.push({
+        key,
+        scope,
+        project: project || null,
+        description: description || null,
+        createdAt: now,
+        updatedAt: now
+      })
+    }
+    this._writeIndex(index)
+  }
+
+  _removeIndexEntry (key, scope, project) {
+    const index = this._readIndex()
+    index.secrets = index.secrets.filter(
+      e => !(e.key === key && e.scope === scope && e.project === (project || null))
+    )
+    this._writeIndex(index)
+  }
+}

package/client/dist/client.d.ts

@@ -0,0 +1,332 @@
+/**
+ * @gokiteam/goki-dev - Main Client
+ *
+ * HTTP client for Goki Developer Tools
+ */
+import { AxiosInstance } from 'axios';
+import type * as Types from './types';
+export interface DevToolsClientConfig {
+    baseUrl?: string;
+    timeout?: number;
+}
+export declare class PubSubClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    /**
+     * Extract short topic name from a full path like 'projects/X/topics/Y' -> 'Y'
+     */
+    private extractTopicName;
+    publish(params: {
+        topic: string;
+        message: any;
+        attributes?: Record<string, string>;
+        traceId?: string;
+    }): Promise<{
+        messageIds: string[];
+    } & {
+        traceId: string;
+    }>;
+    waitForMessage(params: Types.WaitForMessageRequest): Promise<Types.WaitForMessageResponse>;
+    assertMessagePublished(params: Types.AssertMessagePublishedRequest): Promise<Types.AssertMessagePublishedResponse>;
+    getMessages(params?: {
+        filter?: Types.PubSubHistoryFilter;
+        page?: Types.PageOptions;
+        traceId?: string;
+    }): Promise<{
+        messages: Types.PubSubMessage[];
+        total: number;
+    } & {
+        traceId: string;
+    }>;
+    searchMessages(params: {
+        query: string;
+        filter?: Partial<Types.PubSubHistoryFilter>;
+        traceId?: string;
+    }): Promise<{
+        messages: Types.PubSubMessage[];
+        total: number;
+    } & {
+        traceId: string;
+    }>;
+    listTopics(params?: {
+        traceId?: string;
+    }): Promise<{
+        topics: Types.PubSubTopic[];
+        total: number;
+    } & {
+        traceId: string;
+    }>;
+    createTopic(params: {
+        topic: string;
+        traceId?: string;
+    }): Promise<{
+        topic: Types.PubSubTopic;
+    } & {
+        traceId: string;
+    }>;
+    deleteTopic(params: {
+        topic: string;
+        traceId?: string;
+    }): Promise<void>;
+}
+export declare class LoggingClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    getByTrace(params: {
+        traceId: string;
+        queryTraceId?: string;
+    }): Promise<{
+        traceId: string;
+        entries: Types.LogEntry[];
+        count: number;
+    }>;
+    list(params?: {
+        filter?: Types.LogFilter;
+        page?: Types.PageOptions;
+        traceId?: string;
+    }): Promise<{
+        entries: Types.LogEntry[];
+        total: number;
+    } & {
+        traceId: string;
+    }>;
+    clear(params?: {
+        service?: string;
+        traceId?: string;
+    }): Promise<{
+        deletedCount: number;
+    } & {
+        traceId: string;
+    }>;
+    waitForLog(params: Types.WaitForLogRequest): Promise<Types.WaitForLogResponse>;
+    assertNoErrors(params: Types.AssertNoErrorsRequest): Promise<Types.AssertNoErrorsResponse>;
+}
+export declare class PostgresClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    query(params: Types.PostgresQueryRequest): Promise<Types.PostgresQueryResponse>;
+    listTables(params: {
+        database: string;
+        schema?: string;
+        traceId?: string;
+    }): Promise<{
+        tables: {
+            name: string;
+            rowCount: number;
+        }[];
+    } & {
+        traceId: string;
+    }>;
+    listRows(params: {
+        database: string;
+        schema: string;
+        table: string;
+        page?: Types.PageOptions;
+        traceId?: string;
+    }): Promise<{
+        rows: any[];
+        total: number;
+    } & {
+        traceId: string;
+    }>;
+    waitForCondition(params: Types.WaitForConditionRequest & {
+        type: 'postgres';
+    }): Promise<Types.WaitForConditionResponse>;
+}
+export declare class RedisClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    get(params: {
+        key: string;
+        traceId?: string;
+    }): Promise<Types.RedisValue>;
+    scan(params: {
+        pattern: string;
+        count?: number;
+        traceId?: string;
+    }): Promise<{
+        keys: Types.RedisKey[];
+        total: number;
+    } & {
+        traceId: string;
+    }>;
+    delete(params: {
+        key: string;
+        traceId?: string;
+    }): Promise<{
+        deleted: boolean;
+    } & {
+        traceId: string;
+    }>;
+    deletePattern(params: {
+        pattern: string;
+        traceId?: string;
+    }): Promise<{
+        deletedCount: number;
+    } & {
+        traceId: string;
+    }>;
+    waitForCondition(params: Types.WaitForConditionRequest & {
+        type: 'redis';
+    }): Promise<Types.WaitForConditionResponse>;
+}
+export declare class FirestoreClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    /**
+     * Parses a Firestore REST API typed value into a plain JS value.
+     */
+    private parseFirestoreValue;
+    /**
+     * Parses Firestore REST API fields object into a plain JS object.
+     */
+    private parseFirestoreFields;
+    /**
+     * Converts a raw Firestore REST API document to a clean FirestoreDocument.
+     * Raw format: { name: "projects/.../documents/collection/id", fields: { key: { stringValue: "..." } }, ... }
+     * Clean format: { id: "docId", data: { key: "..." } }
+     */
+    private parseRawDocument;
+    getDocument(params: {
+        collection: string;
+        documentId: string;
+        traceId?: string;
+    }): Promise<{
+        document: Types.FirestoreDocument;
+    }>;
+    query(params: {
+        collection: string;
+        where: Types.FirestoreQuery;
+        traceId?: string;
+    }): Promise<{
+        documents: Types.FirestoreDocument[];
+    }>;
+    listDocuments(params: {
+        collection: string;
+        page?: Types.PageOptions;
+        traceId?: string;
+    }): Promise<{
+        documents: Types.FirestoreDocument[];
+        total: number;
+    }>;
+    deleteByQuery(params: Types.DeleteByQueryRequest): Promise<Types.DeleteByQueryResponse>;
+    deleteByPrefix(params: Types.DeleteByPrefixRequest): Promise<Types.DeleteByPrefixResponse>;
+    deleteBatch(params: Types.DeleteBatchRequest): Promise<Types.DeleteBatchResponse>;
+    waitForCondition(params: Types.WaitForConditionRequest & {
+        type: 'firestore';
+    }): Promise<Types.WaitForConditionResponse>;
+}
+export declare class MqttClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    listClients(params?: {
+        traceId?: string;
+    }): Promise<{
+        clients: Types.MqttClientInfo[];
+    } & {
+        traceId: string;
+    }>;
+    getMessages(params?: {
+        filter?: {
+            clientId?: string;
+            topic?: string;
+        };
+        page?: Types.PageOptions;
+        traceId?: string;
+    }): Promise<{
+        messages: Types.MqttMessage[];
+        total: number;
+    } & {
+        traceId: string;
+    }>;
+}
+export declare class DockerClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    list(params?: {
+        traceId?: string;
+    }): Promise<{
+        data: Types.DockerContainer[];
+    } & {
+        traceId: string;
+    }>;
+    start(params: {
+        containerName: string;
+        traceId?: string;
+    }): Promise<void>;
+    stop(params: {
+        containerName: string;
+        traceId?: string;
+    }): Promise<void>;
+    restart(params: {
+        containerName: string;
+        traceId?: string;
+    }): Promise<void>;
+    logs(params: {
+        containerName: string;
+        lines?: number;
+        traceId?: string;
+    }): Promise<{
+        data: string;
+    } & {
+        traceId: string;
+    }>;
+}
+export declare class PlatformClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    getStats(params?: {
+        traceId?: string;
+    }): Promise<{
+        stats: Types.PlatformStats;
+    } & {
+        traceId: string;
+    }>;
+    clearAll(params?: {
+        traceId?: string;
+    }): Promise<{
+        cleared: Record<string, number>;
+    } & {
+        traceId: string;
+    }>;
+    clearServices(params: Types.ClearServiceDataRequest): Promise<Types.ClearServiceDataResponse>;
+    export(params?: {
+        traceId?: string;
+    }): Promise<{
+        export: Types.ExportData;
+    } & {
+        traceId: string;
+    }>;
+}
+export declare class SchedulerClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    triggerTick(params?: {
+        traceId?: string;
+    }): Promise<Types.SchedulerTickResponse>;
+}
+export declare class DevToolsClient {
+    private client;
+    private baseUrl;
+    pubsub: PubSubClient;
+    logging: LoggingClient;
+    postgres: PostgresClient;
+    redis: RedisClient;
+    firestore: FirestoreClient;
+    mqtt: MqttClient;
+    docker: DockerClient;
+    platform: PlatformClient;
+    scheduler: SchedulerClient;
+    constructor(config?: DevToolsClientConfig);
+    generateTraceId(prefix?: string): string;
+}
+export * from './types';